Full Code of kolide/osquery-go for AI

Repository: kolide/osquery-go
Branch: master
Commit: a88c0766cd0d
Files: 43
Total size: 271.5 KB

Directory structure:
gitextract_qak33u0z/

├── .github/
│   └── workflows/
│       └── go.yml
├── .gitignore
├── CONTRIBUTING.md
├── LICENSE
├── Makefile
├── README.md
├── client.go
├── client_test.go
├── examples/
│   ├── call/
│   │   └── main.go
│   ├── config/
│   │   └── main.go
│   ├── distributed/
│   │   └── main.go
│   ├── logger/
│   │   └── main.go
│   ├── query/
│   │   └── main.go
│   └── table/
│       └── main.go
├── gen/
│   └── osquery/
│       ├── GoUnusedProtection__.go
│       ├── osquery-consts.go
│       └── osquery.go
├── go.mod
├── go.sum
├── locker.go
├── locker_test.go
├── mock/
│   └── osquery.go
├── mock_manager.go
├── osquery.thrift
├── plugin/
│   ├── config/
│   │   ├── config.go
│   │   └── config_test.go
│   ├── distributed/
│   │   ├── distributed.go
│   │   └── distributed_test.go
│   ├── logger/
│   │   ├── logger.go
│   │   └── logger_test.go
│   └── table/
│       ├── column.go
│       ├── column_test.go
│       ├── spec.go
│       ├── spec_test.go
│       ├── table.go
│       └── table_test.go
├── server.go
├── server_test.go
├── traces/
│   ├── traces.go
│   └── traces_test.go
└── transport/
    ├── doc.go
    ├── transport.go
    └── transport_windows.go

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/workflows/go.yml
================================================
name: Go

on:
  workflow_dispatch:
  push:
    branches: [main, master]
    tags: '*'
  pull_request:
    branches: '**'

jobs:
  test:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os:
          - ubuntu-latest
          - macos-latest
    steps:
      - uses: actions/checkout@v3

      - name: Set up Go
        uses: actions/setup-go@v4
        with:
          go-version-file: 'go.mod'

      - name: Test
        run: go test -v --race --cover ./...


================================================
FILE: .gitignore
================================================
# Example binaries
example_*

# Glide vendor directory
vendor/

## From https://github.com/github/gitignore/blob/master/Go.gitignore ##

# Binaries for programs and plugins
*.exe
*.dll
*.so
*.dylib

# Test binary, build with `go test -c`
*.test

# Output of the go coverage tool, specifically when used with LiteIDE
*.out

# Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
.glide/

================================================
FILE: CONTRIBUTING.md
================================================
## Code of Conduct

### Our Pledge

In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.

### Our Standards

Examples of behavior that contributes to creating a positive environment
include:

- Using welcoming and inclusive language
- Being respectful of differing viewpoints and experiences
- Gracefully accepting constructive criticism
- Focusing on what is best for the community
- Showing empathy towards other community members

Examples of unacceptable behavior by participants include:

- The use of sexualized language or imagery and unwelcome sexual attention or advances
- Trolling, insulting/derogatory comments, and personal or political attacks
- Public or private harassment
- Publishing others' private information, such as a physical or electronic address, without explicit permission
- Other conduct which could reasonably be considered inappropriate in a professional setting

### Our Responsibilities

Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.

Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.

### Scope

This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.

### Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at hello@kolide.co. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.

Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.

### Attribution

This Code of Conduct is adapted from the Contributor Covenant, version 1.4, available at http://contributor-covenant.org/version/1/4.


================================================
FILE: LICENSE
================================================
MIT License

Copyright 2017 Kolide Inc.

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

================================================
FILE: Makefile
================================================
PATH := $(GOPATH)/bin:$(PATH)
export GO111MODULE=on

all: gen examples

go-mod-check:
	@go help mod > /dev/null || (echo "Your go is too old, no modules. Seek help." && exit 1)

go-mod-download:
	go mod download

deps-go: go-mod-check go-mod-download

deps: deps-go

gen: ./osquery.thrift
	mkdir -p ./gen
	thrift --gen go:package_prefix=github.com/osquery/osquery-go/gen/ -out ./gen ./osquery.thrift
	rm -rf gen/osquery/extension-remote gen/osquery/extension_manager-remote
	gofmt -w ./gen

examples: example_query example_call example_logger example_distributed example_table example_config

example_query: examples/query/*.go
	go build -o example_query ./examples/query/*.go

example_call: examples/call/*.go
	go build -o example_call ./examples/call/*.go

example_logger: examples/logger/*.go
	go build -o example_logger.ext  ./examples/logger/*.go

example_distributed: examples/distributed/*.go
	go build -o example_distributed.ext  ./examples/distributed/*.go

example_table: examples/table/*.go
	go build -o example_table ./examples/table/*.go

example_config: examples/config/*.go
	go build -o example_config ./examples/config/*.go

test: all
	go test -race -cover ./...

clean:
	rm -rf ./build ./gen

.PHONY: all


================================================
FILE: README.md
================================================
# osquery-go

[![GoDoc](https://godoc.org/github.com/osquery/osquery-go?status.svg)](http://godoc.org/github.com/osquery/osquery-go)

[osquery](https://github.com/facebook/osquery) exposes an operating system as a high-performance relational database. This allows you to write SQL-based queries to explore operating system data. With osquery, SQL tables represent abstract concepts such as running processes, loaded kernel modules, open network connections, browser plugins, hardware events or file hashes.

If you're interested in learning more about osquery, visit the [GitHub project](https://github.com/facebook/osquery), the [website](https://osquery.io), and the [users guide](https://osquery.readthedocs.io).

## What is osquery-go?

In osquery, SQL tables, configuration retrieval, log handling, etc. are implemented via a robust plugin and extensions API. This project contains Go bindings for creating osquery extensions in Go. To create an extension, you must create an executable binary which instantiates an `ExtensionManagerServer` and registers the plugins that you would like to be added to osquery. You can then have osquery load the extension in your desired context (ie: in a long running instance of `osqueryd` or during an interactive query session with `osqueryi`). For more information about how this process works at a lower level, see the osquery [wiki](https://osquery.readthedocs.io/en/latest/development/osquery-sdk/).

## Install

This library is compatible with Go Modules. To install:

``` go
go get github.com/osquery/osquery-go
```

## Using the library

### Creating a new osquery table

If you want to create a custom osquery table in Go, you'll need to write an extension which registers the implementation of your table. Consider the following Go program:


```go
package main

import (
	"context"
	"log"
	"os"
	"flag"

	"github.com/osquery/osquery-go"
	"github.com/osquery/osquery-go/plugin/table"
)

func main() {
	socket := flag.String("socket", "", "Path to osquery socket file")
	flag.Parse()
	if *socket == "" {
		log.Fatalf(`Usage: %s --socket SOCKET_PATH`, os.Args[0])
	}

	server, err := osquery.NewExtensionManagerServer("foobar", *socket)
	if err != nil {
		log.Fatalf("Error creating extension: %s\n", err)
	}

	// Create and register a new table plugin with the server.
	// table.NewPlugin requires the table plugin name,
	// a slice of Columns and a Generate function.
	server.RegisterPlugin(table.NewPlugin("foobar", FoobarColumns(), FoobarGenerate))
	if err := server.Run(); err != nil {
		log.Fatalln(err)
	}
}

// FoobarColumns returns the columns that our table will return.
func FoobarColumns() []table.ColumnDefinition {
	return []table.ColumnDefinition{
		table.TextColumn("foo"),
		table.TextColumn("baz"),
	}
}

// FoobarGenerate will be called whenever the table is queried. It should return
// a full table scan.
func FoobarGenerate(ctx context.Context, queryContext table.QueryContext) ([]map[string]string, error) {
	return []map[string]string{
		{
			"foo": "bar",
			"baz": "baz",
		},
		{
			"foo": "bar",
			"baz": "baz",
		},
	}, nil
}
```

To test this code, start an osquery shell and find the path of the osquery extension socket:

```sql
osqueryi --nodisable_extensions
osquery> select value from osquery_flags where name = 'extensions_socket';
+-----------------------------------+
| value                             |
+-----------------------------------+
| /Users/USERNAME/.osquery/shell.em |
+-----------------------------------+
```

Then start the Go extension and have it communicate with osqueryi via the extension socket that you retrieved above:

```bash
go run ./my_table_plugin.go --socket /Users/USERNAME/.osquery/shell.em
```

Alternatively, you can also autoload your extension when starting an osquery shell:

```bash
go build -o my_table_plugin my_table_plugin.go
osqueryi --extension /path/to/my_table_plugin
```

This will register a table called "foobar". As you can see, the table will return two rows:

```sql
osquery> select * from foobar;
+-----+-----+
| foo | baz |
+-----+-----+
| bar | baz |
| bar | baz |
+-----+-----+
osquery>
```

This is obviously a contrived example, but it's easy to imagine the possibilities.

Using the instructions found on the [wiki](https://osquery.readthedocs.io/en/latest/development/osquery-sdk/), you can deploy your extension with an existing osquery deployment.

### Creating logger and config plugins

The process required to create a config and/or logger plugin is very similar to the process outlined above for creating an osquery table. Specifically, you would create an `ExtensionManagerServer` instance in `func main()`, register your plugin and launch the extension as described above. The only difference is that the implementation of your plugin would be different. Each plugin package has a `NewPlugin` function which takes the plugin name as the first argument, followed by a list of required arguments to implement the plugin.
For example, consider the implementation of an example logger plugin:

```go
func main() {
    // create and register the plugin
	server.RegisterPlugin(logger.NewPlugin("example_logger", LogString))
}

func LogString(ctx context.Context, typ logger.LogType, logText string) error {
	log.Printf("%s: %s\n", typ, logText)
	return nil
}
```

Additionally, consider the implementation of an example config plugin:

```go
func main() {
    // create and register the plugin
	server.RegisterPlugin(config.NewPlugin("example", GenerateConfigs))
}

func GenerateConfigs(ctx context.Context) (map[string]string, error) {
	return map[string]string{
		"config1": `
{
  "options": {
    "host_identifier": "hostname",
    "schedule_splay_percent": 10
  },
  "schedule": {
    "macos_kextstat": {
      "query": "SELECT * FROM kernel_extensions;",
      "interval": 10
    },
    "foobar": {
      "query": "SELECT foo, bar, pid FROM foobar_table;",
      "interval": 600
    }
  }
}
`,
	}, nil
}
```

All of these examples and more can be found in the [examples](./examples) subdirectory of this repository.

### Execute queries in Go

This library can also be used to create a Go client for the osqueryd or osqueryi's extension socket. You can use this to add the ability to performantly execute osquery queries to your Go program. Consider the following example:

```go
package main

import (
	"fmt"
	"os"
	"time"

	"github.com/osquery/osquery-go"
)

func main() {
	if len(os.Args) != 3 {
		log.Fatalf("Usage: %s SOCKET_PATH QUERY", os.Args[0])
	}

	client, err := osquery.NewClient(os.Args[1], 10*time.Second)
	if err != nil {
		log.Fatalf("Error creating Thrift client: %v", err)
	}
	defer client.Close()

	resp, err := client.Query(os.Args[2])
	if err != nil {
		log.Fatalf("Error communicating with osqueryd: %v",err)
	}
	if resp.Status.Code != 0 {
		log.Fatalf("osqueryd returned error: %s", resp.Status.Message)
	}

	fmt.Printf("Got results:\n%#v\n", resp.Response)
}
```

### Loading extensions with osqueryd

If you write an extension with a logger or config plugin, you'll likely want to autoload the extensions when `osqueryd` starts. `osqueryd` has a few requirements for autoloading extensions, documented on the [wiki](https://osquery.readthedocs.io/en/latest/deployment/extensions/). Here's a quick example using a logging plugin to get you started:

1. Build the plugin. Make sure to add `.ext` as the file extension. It is required by osqueryd.
```go build -o /usr/local/osquery_extensions/my_logger.ext```

2. Set the correct permissions on the file and directory. If `osqueryd` runs as root, the directory for the extension must only be writable by root.

```
sudo chown -R root /usr/local/osquery_extensions/
```

3. Create an `extensions.load` file with the path of your extension.

```
echo "/usr/local/osquery_extensions/my_logger.ext" > /tmp/extensions.load
```

4. Start `osqueryd` with the `--extensions_autoload` flag.

```
sudo osqueryd --extensions_autoload=/tmp/extensions.load --logger-plugin=my_logger -verbose
```


## Contributing

For more information on contributing to this project, see [CONTRIBUTING.md](./CONTRIBUTING.md).

## Vulnerabilities

If you find a vulnerability in this software, please email [security@kolide.co](mailto:security@kolide.co).


================================================
FILE: client.go
================================================
package osquery

import (
	"context"
	"time"

	"github.com/osquery/osquery-go/gen/osquery"
	"github.com/osquery/osquery-go/traces"
	"github.com/osquery/osquery-go/transport"

	"github.com/apache/thrift/lib/go/thrift"
	"github.com/pkg/errors"
)

const (
	defaultWaitTime    = 200 * time.Millisecond
	defaultMaxWaitTime = 1 * time.Minute
)

// ExtensionManagerClient is a wrapper for the osquery Thrift extensions API.
type ExtensionManagerClient struct {
	client    osquery.ExtensionManager
	transport thrift.TTransport

	waitTime    time.Duration
	maxWaitTime time.Duration
	lock        *locker
}

type ClientOption func(*ExtensionManagerClient)

// WaitTime sets the default amount of wait time for the osquery socket to free up. You can override this on a per
// call basis by setting a context deadline
func DefaultWaitTime(d time.Duration) ClientOption {
	return func(c *ExtensionManagerClient) {
		c.waitTime = d
	}
}

// MaxWaitTime is the maximum amount of time something is allowed to wait for the osquery socket. This takes precedence
// over the context deadline.
func MaxWaitTime(d time.Duration) ClientOption {
	return func(c *ExtensionManagerClient) {
		c.maxWaitTime = d
	}
}

// NewClient creates a new client communicating to osquery over the socket at
// the provided path. If resolving the address or connecting to the socket
// fails, this function will error.
func NewClient(path string, socketOpenTimeout time.Duration, opts ...ClientOption) (*ExtensionManagerClient, error) {
	c := &ExtensionManagerClient{
		waitTime:    defaultWaitTime,
		maxWaitTime: defaultMaxWaitTime,
	}

	for _, opt := range opts {
		opt(c)
	}

	if c.waitTime > c.maxWaitTime {
		return nil, errors.New("default wait time larger than max wait time")
	}

	c.lock = NewLocker(c.waitTime, c.maxWaitTime)

	if c.client == nil {
		trans, err := transport.Open(path, socketOpenTimeout)
		if err != nil {
			return nil, err
		}

		c.transport = trans
		c.client = osquery.NewExtensionManagerClientFactory(
			trans,
			thrift.NewTBinaryProtocolFactoryDefault(),
		)
	}

	return c, nil
}

// Close should be called to close the transport when use of the client is
// completed.
func (c *ExtensionManagerClient) Close() {
	if c.transport != nil && c.transport.IsOpen() {
		c.transport.Close()
	}
}

// Ping requests metadata from the extension manager, using a new background context
func (c *ExtensionManagerClient) Ping() (*osquery.ExtensionStatus, error) {
	return c.PingContext(context.Background())
}

// PingContext requests metadata from the extension manager.
func (c *ExtensionManagerClient) PingContext(ctx context.Context) (*osquery.ExtensionStatus, error) {
	if err := c.lock.Lock(ctx); err != nil {
		return nil, err
	}
	defer c.lock.Unlock()
	return c.client.Ping(ctx)
}

// Call requests a call to an extension (or core) registry plugin, using a new background context
func (c *ExtensionManagerClient) Call(registry, item string, request osquery.ExtensionPluginRequest) (*osquery.ExtensionResponse, error) {
	return c.CallContext(context.Background(), registry, item, request)
}

// CallContext requests a call to an extension (or core) registry plugin.
func (c *ExtensionManagerClient) CallContext(ctx context.Context, registry, item string, request osquery.ExtensionPluginRequest) (*osquery.ExtensionResponse, error) {
	ctx, span := traces.StartSpan(ctx, "ExtensionManagerClient.CallContext")
	defer span.End()

	if err := c.lock.Lock(ctx); err != nil {
		return nil, err
	}
	defer c.lock.Unlock()
	return c.client.Call(ctx, registry, item, request)
}

// Extensions requests the list of active registered extensions, using a new background context
func (c *ExtensionManagerClient) Extensions() (osquery.InternalExtensionList, error) {
	return c.ExtensionsContext(context.Background())
}

// ExtensionsContext requests the list of active registered extensions.
func (c *ExtensionManagerClient) ExtensionsContext(ctx context.Context) (osquery.InternalExtensionList, error) {
	ctx, span := traces.StartSpan(ctx, "ExtensionManagerClient.ExtensionsContext")
	defer span.End()

	if err := c.lock.Lock(ctx); err != nil {
		return nil, err
	}
	defer c.lock.Unlock()
	return c.client.Extensions(ctx)
}

// RegisterExtension registers the extension plugins with the osquery process, using a new background context
func (c *ExtensionManagerClient) RegisterExtension(info *osquery.InternalExtensionInfo, registry osquery.ExtensionRegistry) (*osquery.ExtensionStatus, error) {
	return c.RegisterExtensionContext(context.Background(), info, registry)
}

// RegisterExtensionContext registers the extension plugins with the osquery process.
func (c *ExtensionManagerClient) RegisterExtensionContext(ctx context.Context, info *osquery.InternalExtensionInfo, registry osquery.ExtensionRegistry) (*osquery.ExtensionStatus, error) {
	ctx, span := traces.StartSpan(ctx, "ExtensionManagerClient.RegisterExtensionContext")
	defer span.End()

	if err := c.lock.Lock(ctx); err != nil {
		return nil, err
	}
	defer c.lock.Unlock()
	return c.client.RegisterExtension(ctx, info, registry)
}

// DeregisterExtension de-registers the extension plugins with the osquery process, using a new background context
func (c *ExtensionManagerClient) DeregisterExtension(uuid osquery.ExtensionRouteUUID) (*osquery.ExtensionStatus, error) {
	return c.DeregisterExtensionContext(context.Background(), uuid)
}

// DeregisterExtensionContext de-registers the extension plugins with the osquery process.
func (c *ExtensionManagerClient) DeregisterExtensionContext(ctx context.Context, uuid osquery.ExtensionRouteUUID) (*osquery.ExtensionStatus, error) {
	ctx, span := traces.StartSpan(ctx, "ExtensionManagerClient.DeregisterExtensionContext")
	defer span.End()

	if err := c.lock.Lock(ctx); err != nil {
		return nil, err
	}
	defer c.lock.Unlock()
	return c.client.DeregisterExtension(ctx, uuid)
}

// Options requests the list of bootstrap or configuration options, using a new background context.
func (c *ExtensionManagerClient) Options() (osquery.InternalOptionList, error) {
	return c.OptionsContext(context.Background())
}

// OptionsContext requests the list of bootstrap or configuration options.
func (c *ExtensionManagerClient) OptionsContext(ctx context.Context) (osquery.InternalOptionList, error) {
	ctx, span := traces.StartSpan(ctx, "ExtensionManagerClient.OptionsContext")
	defer span.End()

	if err := c.lock.Lock(ctx); err != nil {
		return nil, err
	}
	defer c.lock.Unlock()
	return c.client.Options(ctx)
}

// Query requests a query to be run and returns the extension
// response, using a new background context.  Consider using the
// QueryRow or QueryRows helpers for a more friendly interface.
func (c *ExtensionManagerClient) Query(sql string) (*osquery.ExtensionResponse, error) {
	return c.QueryContext(context.Background(), sql)
}

// QueryContext requests a query to be run and returns the extension response.
// Consider using the QueryRow or QueryRows helpers for a more friendly
// interface.
func (c *ExtensionManagerClient) QueryContext(ctx context.Context, sql string) (*osquery.ExtensionResponse, error) {
	ctx, span := traces.StartSpan(ctx, "ExtensionManagerClient.QueryContext")
	defer span.End()

	if err := c.lock.Lock(ctx); err != nil {
		return nil, err
	}
	defer c.lock.Unlock()
	return c.client.Query(ctx, sql)
}

// QueryRows is a helper that executes the requested query and returns the
// results. It handles checking both the transport level errors and the osquery
// internal errors by returning a normal Go error type.
func (c *ExtensionManagerClient) QueryRows(sql string) ([]map[string]string, error) {
	return c.QueryRowsContext(context.Background(), sql)
}

// QueryRowsContext is a helper that executes the requested query and returns the
// results. It handles checking both the transport level errors and the osquery
// internal errors by returning a normal Go error type.
func (c *ExtensionManagerClient) QueryRowsContext(ctx context.Context, sql string) ([]map[string]string, error) {
	ctx, span := traces.StartSpan(ctx, "ExtensionManagerClient.QueryRowsContext")
	defer span.End()

	res, err := c.QueryContext(ctx, sql)
	if err != nil {
		return nil, errors.Wrap(err, "transport error in query")
	}
	if res.Status == nil {
		return nil, errors.New("query returned nil status")
	}
	if res.Status.Code != 0 {
		return nil, errors.Errorf("query returned error: %s", res.Status.Message)
	}
	return res.Response, nil

}

// QueryRow behaves similarly to QueryRows, but it returns an error if the
// query does not return exactly one row.
func (c *ExtensionManagerClient) QueryRow(sql string) (map[string]string, error) {
	return c.QueryRowContext(context.Background(), sql)
}

// QueryRowContext behaves similarly to QueryRows, but it returns an error if the
// query does not return exactly one row.
func (c *ExtensionManagerClient) QueryRowContext(ctx context.Context, sql string) (map[string]string, error) {
	ctx, span := traces.StartSpan(ctx, "ExtensionManagerClient.QueryRowContext")
	defer span.End()

	res, err := c.QueryRowsContext(ctx, sql)
	if err != nil {
		return nil, err
	}
	if len(res) != 1 {
		return nil, errors.Errorf("expected 1 row, got %d", len(res))
	}
	return res[0], nil
}

// GetQueryColumns requests the columns returned by the parsed query, using a new background context.
func (c *ExtensionManagerClient) GetQueryColumns(sql string) (*osquery.ExtensionResponse, error) {
	return c.GetQueryColumnsContext(context.Background(), sql)
}

// GetQueryColumnsContext requests the columns returned by the parsed query.
func (c *ExtensionManagerClient) GetQueryColumnsContext(ctx context.Context, sql string) (*osquery.ExtensionResponse, error) {
	ctx, span := traces.StartSpan(ctx, "ExtensionManagerClient.GetQueryColumnsContext")
	defer span.End()

	if err := c.lock.Lock(ctx); err != nil {
		return nil, err
	}
	defer c.lock.Unlock()
	return c.client.GetQueryColumns(ctx, sql)
}


================================================
FILE: client_test.go
================================================
package osquery

import (
	"context"
	"errors"
	"fmt"
	"os"
	"sync"
	"testing"
	"time"

	"github.com/osquery/osquery-go/gen/osquery"
	"github.com/osquery/osquery-go/mock"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestQueryRows(t *testing.T) {
	t.Parallel()
	mock := &mock.ExtensionManager{}
	client, err := NewClient("", 5*time.Second, WithOsqueryThriftClient(mock))
	require.NoError(t, err)

	// Transport related error
	mock.QueryFunc = func(ctx context.Context, sql string) (*osquery.ExtensionResponse, error) {
		return nil, errors.New("boom!")
	}
	rows, err := client.QueryRows("select 1")
	assert.NotNil(t, err)
	row, err := client.QueryRow("select 1")
	assert.NotNil(t, err)

	// Nil status
	mock.QueryFunc = func(ctx context.Context, sql string) (*osquery.ExtensionResponse, error) {
		return &osquery.ExtensionResponse{}, nil
	}
	rows, err = client.QueryRows("select 1")
	assert.NotNil(t, err)
	row, err = client.QueryRow("select 1")
	assert.NotNil(t, err)

	// Query error
	mock.QueryFunc = func(ctx context.Context, sql string) (*osquery.ExtensionResponse, error) {
		return &osquery.ExtensionResponse{
			Status: &osquery.ExtensionStatus{Code: 1, Message: "bad query"},
		}, nil
	}
	rows, err = client.QueryRows("select bad query")
	assert.NotNil(t, err)
	row, err = client.QueryRow("select bad query")
	assert.NotNil(t, err)

	// Good query (one row)
	expectedRows := []map[string]string{
		{"1": "1"},
	}
	mock.QueryFunc = func(ctx context.Context, sql string) (*osquery.ExtensionResponse, error) {
		return &osquery.ExtensionResponse{
			Status:   &osquery.ExtensionStatus{Code: 0, Message: "OK"},
			Response: expectedRows,
		}, nil
	}
	rows, err = client.QueryRows("select 1")
	assert.Nil(t, err)
	assert.Equal(t, expectedRows, rows)
	row, err = client.QueryRow("select 1")
	assert.Nil(t, err)
	assert.Equal(t, expectedRows[0], row)

	// Good query (multiple rows)
	expectedRows = []map[string]string{
		{"1": "1"},
		{"1": "2"},
	}
	mock.QueryFunc = func(ctx context.Context, sql string) (*osquery.ExtensionResponse, error) {
		return &osquery.ExtensionResponse{
			Status:   &osquery.ExtensionStatus{Code: 0, Message: "OK"},
			Response: expectedRows,
		}, nil
	}
	rows, err = client.QueryRows("select 1 union select 2")
	assert.Nil(t, err)
	assert.Equal(t, expectedRows, rows)
	row, err = client.QueryRow("select 1 union select 2")
	assert.NotNil(t, err)
}

// TestLocking tests the the client correctly locks access to the osquery socket. Thrift only supports a single
// actor on the socket at a time, this means that in parallel go code, it's very easy to have messages get
// crossed and generate errors. This tests to ensure the locking works
func TestLocking(t *testing.T) {
	t.Parallel()

	sock := os.Getenv("OSQ_SOCKET")
	if sock == "" {
		t.Skip("no osquery socket specified")
	}

	osq, err := NewClient(sock, 5*time.Second)
	require.NoError(t, err)

	// The issue we're testing is about multithreaded access. Let's hammer on it!
	wait := sync.WaitGroup{}
	for i := 0; i < 100; i++ {
		wait.Add(1)
		go func() {
			defer wait.Done()

			status, err := osq.Ping()
			require.NoError(t, err, "call to Ping()")
			if err != nil {
				require.Equal(t, 0, status.Code, fmt.Errorf("ping returned %d: %s", status.Code, status.Message))
			}
		}()
	}

	wait.Wait()
}

func TestLockTimeouts(t *testing.T) {
	t.Parallel()
	mock := &mock.ExtensionManager{}
	client, err := NewClient("", 5*time.Second, WithOsqueryThriftClient(mock), DefaultWaitTime(100*time.Millisecond), DefaultWaitTime(5*time.Second))
	require.NoError(t, err)

	wait := sync.WaitGroup{}

	errChan := make(chan error, 10)
	for i := 0; i < 3; i++ {
		wait.Add(1)
		go func() {
			defer wait.Done()

			ctx, cancel := context.WithTimeout(context.TODO(), 100*time.Millisecond)
			defer cancel()

			errChan <- client.SlowLocker(ctx, 75*time.Millisecond)
		}()
	}

	wait.Wait()
	close(errChan)

	var successCount, errCount int
	for err := range errChan {
		if err == nil {
			successCount += 1
		} else {
			errCount += 1
		}
	}

	assert.Equal(t, 2, successCount, "expected success count")
	assert.Equal(t, 1, errCount, "expected error count")
}

// WithOsqueryThriftClient sets the underlying thrift client. This can be used to set a mock
func WithOsqueryThriftClient(client osquery.ExtensionManager) ClientOption {
	return func(c *ExtensionManagerClient) {
		c.client = client
	}
}

// SlowLocker attempts to emulate a slow sql routine, so we can test how lock timeouts work.
func (c *ExtensionManagerClient) SlowLocker(ctx context.Context, d time.Duration) error {
	if err := c.lock.Lock(ctx); err != nil {
		return err
	}
	defer c.lock.Unlock()
	time.Sleep(d)
	return nil
}


================================================
FILE: examples/call/main.go
================================================
package main

import (
	"fmt"
	"os"
	"time"

	"github.com/osquery/osquery-go"
)

func main() {
	if len(os.Args) != 5 {
		fmt.Printf(`Usage: %s SOCKET_PATH REGISTRY_NAME PLUGIN_NAME ACTION

Calls the provided action for the plugin with the given registry and plugin
name.
`, os.Args[0])
		os.Exit(1)
	}

	socketPath := os.Args[1]
	registryName := os.Args[2]
	pluginName := os.Args[3]
	action := os.Args[4]

	client, err := osquery.NewClient(socketPath, 10*time.Second)
	if err != nil {
		fmt.Println("Error creating Thrift client: " + err.Error())
		os.Exit(1)
	}
	defer client.Close()

	resp, err := client.Call(registryName, pluginName, map[string]string{"action": action})
	if err != nil {
		fmt.Println("Error communicating with osqueryd: " + err.Error())
		os.Exit(1)
	}
	if resp.Status.Code != 0 {
		fmt.Println("osqueryd returned error: " + resp.Status.Message)
		os.Exit(1)
	}

	fmt.Printf("Got results:\n%#v\n", resp.Response)
}


================================================
FILE: examples/config/main.go
================================================
package main

import (
	"context"
	"flag"
	"log"
	"time"

	"github.com/osquery/osquery-go"
	"github.com/osquery/osquery-go/plugin/config"
)

var (
	socket   = flag.String("socket", "", "Path to the extensions UNIX domain socket")
	timeout  = flag.Int("timeout", 3, "Seconds to wait for autoloaded extensions")
	interval = flag.Int("interval", 3, "Seconds delay between connectivity checks")
)

func main() {
	flag.Parse()

	if *socket == "" {
		log.Fatalln("Missing required --socket argument")
	}

	serverTimeout := osquery.ServerTimeout(
		time.Second * time.Duration(*timeout),
	)
	serverPingInterval := osquery.ServerPingInterval(
		time.Second * time.Duration(*interval),
	)

	server, err := osquery.NewExtensionManagerServer(
		"example_extension",
		*socket,
		serverTimeout,
		serverPingInterval,
	)

	if err != nil {
		log.Fatalf("Error creating extension: %s\n", err)
	}
	server.RegisterPlugin(config.NewPlugin("example_config", GenerateConfigs))
	if err := server.Run(); err != nil {
		log.Fatal(err)
	}
}

func GenerateConfigs(ctx context.Context) (map[string]string, error) {
	return map[string]string{
		"config1": `
{
  "options": {
    "host_identifier": "hostname",
    "schedule_splay_percent": 10
  },
  "schedule": {
    "macos_kextstat": {
      "query": "SELECT * FROM kernel_extensions;",
      "interval": 10
    },
    "foobar": {
      "query": "SELECT foo, bar, pid FROM foobar_table;",
      "interval": 600
    }
  }
}
`,
	}, nil
}


================================================
FILE: examples/distributed/main.go
================================================
package main

import (
	"context"
	"flag"
	"fmt"
	"log"

	"github.com/osquery/osquery-go"
	"github.com/osquery/osquery-go/plugin/distributed"
)

func main() {
	socketPath := flag.String("socket", "", "path to osqueryd extensions socket")
	flag.Int("timeout", 0, "")
	flag.Int("interval", 0, "")
	flag.Parse()

	server, err := osquery.NewExtensionManagerServer("example_distributed", *socketPath)
	if err != nil {
		log.Fatalf("Error creating extension: %s\n", err)
	}
	server.RegisterPlugin(distributed.NewPlugin("example_distributed", getQueries, writeResults))
	if err := server.Run(); err != nil {
		log.Fatal(err)
	}
}

func getQueries(ctx context.Context) (*distributed.GetQueriesResult, error) {
	return &distributed.GetQueriesResult{Queries: map[string]string{"time": "select * from time"}}, nil
}

func writeResults(ctx context.Context, results []distributed.Result) error {
	fmt.Println(results)
	return nil
}


================================================
FILE: examples/logger/main.go
================================================
package main

import (
	"context"
	"flag"
	"log"

	"github.com/osquery/osquery-go"
	"github.com/osquery/osquery-go/plugin/logger"
)

func main() {
	socketPath := flag.String("socket", "", "path to osqueryd extensions socket")
	flag.Int("timeout", 0, "")
	flag.Int("interval", 0, "")
	flag.Parse()

	server, err := osquery.NewExtensionManagerServer("example_logger", *socketPath)
	if err != nil {
		log.Fatalf("Error creating extension: %s\n", err)
	}
	server.RegisterPlugin(logger.NewPlugin("example_logger", LogString))
	if err := server.Run(); err != nil {
		log.Fatal(err)
	}
}

func LogString(ctx context.Context, typ logger.LogType, logText string) error {
	log.Printf("%s: %s\n", typ, logText)
	return nil
}


================================================
FILE: examples/query/main.go
================================================
package main

import (
	"fmt"
	"os"
	"time"

	"github.com/osquery/osquery-go"
)

func main() {
	if len(os.Args) != 3 {
		fmt.Printf(`Usage: %s SOCKET_PATH QUERY\n

Requests osqueryd to run the provided query and prints the results.
`, os.Args[0])
		os.Exit(1)
	}

	client, err := osquery.NewClient(os.Args[1], 10*time.Second)
	if err != nil {
		fmt.Println("Error creating Thrift client: " + err.Error())
		os.Exit(1)
	}
	defer client.Close()

	resp, err := client.Query(os.Args[2])
	if err != nil {
		fmt.Println("Error communicating with osqueryd: " + err.Error())
		os.Exit(1)
	}
	if resp.Status.Code != 0 {
		fmt.Println("osqueryd returned error: " + resp.Status.Message)
		os.Exit(1)
	}

	fmt.Printf("Got results:\n%#v\n", resp.Response)
}


================================================
FILE: examples/table/main.go
================================================
package main

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/osquery/osquery-go"
	"github.com/osquery/osquery-go/plugin/table"
)

var (
	socket   = flag.String("socket", "", "Path to the extensions UNIX domain socket")
	timeout  = flag.Int("timeout", 3, "Seconds to wait for autoloaded extensions")
	interval = flag.Int("interval", 3, "Seconds delay between connectivity checks")
	spec     = flag.Bool("spec", false, "Don't run as a plugin, instead print the table spec")
)

func main() {
	flag.Parse()

	tbl := table.NewPlugin("example_table", ExampleColumns(), ExampleGenerate, table.WithDescription("A simple example table"))

	if *spec {
		tableSpec, err := json.MarshalIndent(tbl.Spec(), "", "  ")
		if err != nil {
			log.Fatalf("Error marshalling spec: %s\n", err)
		}

		fmt.Printf("%s\n", tableSpec)
		os.Exit(0)
	}

	if *socket == "" {
		log.Fatalln("Missing required --socket argument")
	}
	serverTimeout := osquery.ServerTimeout(
		time.Second * time.Duration(*timeout),
	)
	serverPingInterval := osquery.ServerPingInterval(
		time.Second * time.Duration(*interval),
	)

	server, err := osquery.NewExtensionManagerServer(
		"example_extension",
		*socket,
		serverTimeout,
		serverPingInterval,
	)

	if err != nil {
		log.Fatalf("Error creating extension: %s\n", err)
	}
	server.RegisterPlugin(tbl)
	if err := server.Run(); err != nil {
		log.Fatal(err)
	}
}

func ExampleColumns() []table.ColumnDefinition {
	return []table.ColumnDefinition{
		table.TextColumn("text", table.ColumnDescription("Some text")),
		table.IntegerColumn("integer"),
		table.BigIntColumn("big_int"),
		table.DoubleColumn("double"),
	}
}

func ExampleGenerate(ctx context.Context, queryContext table.QueryContext) ([]map[string]string, error) {
	return []map[string]string{
		{
			"text":    "hello world",
			"integer": "123",
			"big_int": "-1234567890",
			"double":  "3.14159",
		},
	}, nil
}


================================================
FILE: gen/osquery/GoUnusedProtection__.go
================================================
// Code generated by Thrift Compiler (0.16.0). DO NOT EDIT.

package osquery

var GoUnusedProtection__ int


================================================
FILE: gen/osquery/osquery-consts.go
================================================
// Code generated by Thrift Compiler (0.16.0). DO NOT EDIT.

package osquery

import (
	"bytes"
	"context"
	"fmt"
	thrift "github.com/apache/thrift/lib/go/thrift"
	"time"
)

// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = context.Background
var _ = time.Now
var _ = bytes.Equal

func init() {
}


================================================
FILE: gen/osquery/osquery.go
================================================
// Code generated by Thrift Compiler (0.16.0). DO NOT EDIT.

package osquery

import (
	"bytes"
	"context"
	"database/sql/driver"
	"errors"
	"fmt"
	thrift "github.com/apache/thrift/lib/go/thrift"
	"time"
)

// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = context.Background
var _ = time.Now
var _ = bytes.Equal

type ExtensionCode int64

const (
	ExtensionCode_EXT_SUCCESS ExtensionCode = 0
	ExtensionCode_EXT_FAILED  ExtensionCode = 1
	ExtensionCode_EXT_FATAL   ExtensionCode = 2
)

func (p ExtensionCode) String() string {
	switch p {
	case ExtensionCode_EXT_SUCCESS:
		return "EXT_SUCCESS"
	case ExtensionCode_EXT_FAILED:
		return "EXT_FAILED"
	case ExtensionCode_EXT_FATAL:
		return "EXT_FATAL"
	}
	return "<UNSET>"
}

func ExtensionCodeFromString(s string) (ExtensionCode, error) {
	switch s {
	case "EXT_SUCCESS":
		return ExtensionCode_EXT_SUCCESS, nil
	case "EXT_FAILED":
		return ExtensionCode_EXT_FAILED, nil
	case "EXT_FATAL":
		return ExtensionCode_EXT_FATAL, nil
	}
	return ExtensionCode(0), fmt.Errorf("not a valid ExtensionCode string")
}

func ExtensionCodePtr(v ExtensionCode) *ExtensionCode { return &v }

func (p ExtensionCode) MarshalText() ([]byte, error) {
	return []byte(p.String()), nil
}

func (p *ExtensionCode) UnmarshalText(text []byte) error {
	q, err := ExtensionCodeFromString(string(text))
	if err != nil {
		return err
	}
	*p = q
	return nil
}

func (p *ExtensionCode) Scan(value interface{}) error {
	v, ok := value.(int64)
	if !ok {
		return errors.New("Scan value is not int64")
	}
	*p = ExtensionCode(v)
	return nil
}

func (p *ExtensionCode) Value() (driver.Value, error) {
	if p == nil {
		return nil, nil
	}
	return int64(*p), nil
}

type ExtensionPluginRequest map[string]string

func ExtensionPluginRequestPtr(v ExtensionPluginRequest) *ExtensionPluginRequest { return &v }

type ExtensionPluginResponse []map[string]string

func ExtensionPluginResponsePtr(v ExtensionPluginResponse) *ExtensionPluginResponse { return &v }

type InternalOptionList map[string]*InternalOptionInfo

func InternalOptionListPtr(v InternalOptionList) *InternalOptionList { return &v }

type ExtensionRouteUUID int64

func ExtensionRouteUUIDPtr(v ExtensionRouteUUID) *ExtensionRouteUUID { return &v }

type ExtensionRouteTable map[string]ExtensionPluginResponse

func ExtensionRouteTablePtr(v ExtensionRouteTable) *ExtensionRouteTable { return &v }

type ExtensionRegistry map[string]ExtensionRouteTable

func ExtensionRegistryPtr(v ExtensionRegistry) *ExtensionRegistry { return &v }

type InternalExtensionList map[ExtensionRouteUUID]*InternalExtensionInfo

func InternalExtensionListPtr(v InternalExtensionList) *InternalExtensionList { return &v }

// Attributes:
//  - Value
//  - DefaultValue
//  - Type
type InternalOptionInfo struct {
	Value        string `thrift:"value,1" db:"value" json:"value"`
	DefaultValue string `thrift:"default_value,2" db:"default_value" json:"default_value"`
	Type         string `thrift:"type,3" db:"type" json:"type"`
}

func NewInternalOptionInfo() *InternalOptionInfo {
	return &InternalOptionInfo{}
}

func (p *InternalOptionInfo) GetValue() string {
	return p.Value
}

func (p *InternalOptionInfo) GetDefaultValue() string {
	return p.DefaultValue
}

func (p *InternalOptionInfo) GetType() string {
	return p.Type
}
func (p *InternalOptionInfo) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField3(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *InternalOptionInfo) ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(ctx); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Value = v
	}
	return nil
}

func (p *InternalOptionInfo) ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(ctx); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.DefaultValue = v
	}
	return nil
}

func (p *InternalOptionInfo) ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(ctx); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.Type = v
	}
	return nil
}

func (p *InternalOptionInfo) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "InternalOptionInfo"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField1(ctx, oprot); err != nil {
			return err
		}
		if err := p.writeField2(ctx, oprot); err != nil {
			return err
		}
		if err := p.writeField3(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *InternalOptionInfo) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "value", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:value: ", p), err)
	}
	if err := oprot.WriteString(ctx, string(p.Value)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.value (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:value: ", p), err)
	}
	return err
}

func (p *InternalOptionInfo) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "default_value", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:default_value: ", p), err)
	}
	if err := oprot.WriteString(ctx, string(p.DefaultValue)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.default_value (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:default_value: ", p), err)
	}
	return err
}

func (p *InternalOptionInfo) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "type", thrift.STRING, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:type: ", p), err)
	}
	if err := oprot.WriteString(ctx, string(p.Type)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.type (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:type: ", p), err)
	}
	return err
}

func (p *InternalOptionInfo) Equals(other *InternalOptionInfo) bool {
	if p == other {
		return true
	} else if p == nil || other == nil {
		return false
	}
	if p.Value != other.Value {
		return false
	}
	if p.DefaultValue != other.DefaultValue {
		return false
	}
	if p.Type != other.Type {
		return false
	}
	return true
}

func (p *InternalOptionInfo) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InternalOptionInfo(%+v)", *p)
}

// Attributes:
//  - Name
//  - Version
//  - SdkVersion
//  - MinSdkVersion
type InternalExtensionInfo struct {
	Name          string `thrift:"name,1" db:"name" json:"name"`
	Version       string `thrift:"version,2" db:"version" json:"version"`
	SdkVersion    string `thrift:"sdk_version,3" db:"sdk_version" json:"sdk_version"`
	MinSdkVersion string `thrift:"min_sdk_version,4" db:"min_sdk_version" json:"min_sdk_version"`
}

func NewInternalExtensionInfo() *InternalExtensionInfo {
	return &InternalExtensionInfo{}
}

func (p *InternalExtensionInfo) GetName() string {
	return p.Name
}

func (p *InternalExtensionInfo) GetVersion() string {
	return p.Version
}

func (p *InternalExtensionInfo) GetSdkVersion() string {
	return p.SdkVersion
}

func (p *InternalExtensionInfo) GetMinSdkVersion() string {
	return p.MinSdkVersion
}
func (p *InternalExtensionInfo) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField3(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		case 4:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField4(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *InternalExtensionInfo) ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(ctx); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Name = v
	}
	return nil
}

func (p *InternalExtensionInfo) ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(ctx); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.Version = v
	}
	return nil
}

func (p *InternalExtensionInfo) ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(ctx); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.SdkVersion = v
	}
	return nil
}

func (p *InternalExtensionInfo) ReadField4(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(ctx); err != nil {
		return thrift.PrependError("error reading field 4: ", err)
	} else {
		p.MinSdkVersion = v
	}
	return nil
}

func (p *InternalExtensionInfo) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "InternalExtensionInfo"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField1(ctx, oprot); err != nil {
			return err
		}
		if err := p.writeField2(ctx, oprot); err != nil {
			return err
		}
		if err := p.writeField3(ctx, oprot); err != nil {
			return err
		}
		if err := p.writeField4(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *InternalExtensionInfo) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "name", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:name: ", p), err)
	}
	if err := oprot.WriteString(ctx, string(p.Name)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.name (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:name: ", p), err)
	}
	return err
}

func (p *InternalExtensionInfo) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "version", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:version: ", p), err)
	}
	if err := oprot.WriteString(ctx, string(p.Version)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.version (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:version: ", p), err)
	}
	return err
}

func (p *InternalExtensionInfo) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "sdk_version", thrift.STRING, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:sdk_version: ", p), err)
	}
	if err := oprot.WriteString(ctx, string(p.SdkVersion)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.sdk_version (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:sdk_version: ", p), err)
	}
	return err
}

func (p *InternalExtensionInfo) writeField4(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "min_sdk_version", thrift.STRING, 4); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:min_sdk_version: ", p), err)
	}
	if err := oprot.WriteString(ctx, string(p.MinSdkVersion)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.min_sdk_version (4) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 4:min_sdk_version: ", p), err)
	}
	return err
}

func (p *InternalExtensionInfo) Equals(other *InternalExtensionInfo) bool {
	if p == other {
		return true
	} else if p == nil || other == nil {
		return false
	}
	if p.Name != other.Name {
		return false
	}
	if p.Version != other.Version {
		return false
	}
	if p.SdkVersion != other.SdkVersion {
		return false
	}
	if p.MinSdkVersion != other.MinSdkVersion {
		return false
	}
	return true
}

func (p *InternalExtensionInfo) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("InternalExtensionInfo(%+v)", *p)
}

// Attributes:
//  - Code
//  - Message
//  - UUID
type ExtensionStatus struct {
	Code    int32              `thrift:"code,1" db:"code" json:"code"`
	Message string             `thrift:"message,2" db:"message" json:"message"`
	UUID    ExtensionRouteUUID `thrift:"uuid,3" db:"uuid" json:"uuid"`
}

func NewExtensionStatus() *ExtensionStatus {
	return &ExtensionStatus{}
}

func (p *ExtensionStatus) GetCode() int32 {
	return p.Code
}

func (p *ExtensionStatus) GetMessage() string {
	return p.Message
}

func (p *ExtensionStatus) GetUUID() ExtensionRouteUUID {
	return p.UUID
}
func (p *ExtensionStatus) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField1(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.I64 {
				if err := p.ReadField3(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionStatus) ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(ctx); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Code = v
	}
	return nil
}

func (p *ExtensionStatus) ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(ctx); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *ExtensionStatus) ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(ctx); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		temp := ExtensionRouteUUID(v)
		p.UUID = temp
	}
	return nil
}

func (p *ExtensionStatus) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "ExtensionStatus"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField1(ctx, oprot); err != nil {
			return err
		}
		if err := p.writeField2(ctx, oprot); err != nil {
			return err
		}
		if err := p.writeField3(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionStatus) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "code", thrift.I32, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:code: ", p), err)
	}
	if err := oprot.WriteI32(ctx, int32(p.Code)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.code (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:code: ", p), err)
	}
	return err
}

func (p *ExtensionStatus) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "message", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:message: ", p), err)
	}
	if err := oprot.WriteString(ctx, string(p.Message)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.message (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:message: ", p), err)
	}
	return err
}

func (p *ExtensionStatus) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "uuid", thrift.I64, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:uuid: ", p), err)
	}
	if err := oprot.WriteI64(ctx, int64(p.UUID)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.uuid (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:uuid: ", p), err)
	}
	return err
}

func (p *ExtensionStatus) Equals(other *ExtensionStatus) bool {
	if p == other {
		return true
	} else if p == nil || other == nil {
		return false
	}
	if p.Code != other.Code {
		return false
	}
	if p.Message != other.Message {
		return false
	}
	if p.UUID != other.UUID {
		return false
	}
	return true
}

func (p *ExtensionStatus) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionStatus(%+v)", *p)
}

// Attributes:
//  - Status
//  - Response
type ExtensionResponse struct {
	Status   *ExtensionStatus        `thrift:"status,1" db:"status" json:"status"`
	Response ExtensionPluginResponse `thrift:"response,2" db:"response" json:"response"`
}

func NewExtensionResponse() *ExtensionResponse {
	return &ExtensionResponse{}
}

var ExtensionResponse_Status_DEFAULT *ExtensionStatus

func (p *ExtensionResponse) GetStatus() *ExtensionStatus {
	if !p.IsSetStatus() {
		return ExtensionResponse_Status_DEFAULT
	}
	return p.Status
}

func (p *ExtensionResponse) GetResponse() ExtensionPluginResponse {
	return p.Response
}
func (p *ExtensionResponse) IsSetStatus() bool {
	return p.Status != nil
}

func (p *ExtensionResponse) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.LIST {
				if err := p.ReadField2(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionResponse) ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
	p.Status = &ExtensionStatus{}
	if err := p.Status.Read(ctx, iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Status), err)
	}
	return nil
}

func (p *ExtensionResponse) ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin(ctx)
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make(ExtensionPluginResponse, 0, size)
	p.Response = tSlice
	for i := 0; i < size; i++ {
		_, _, size, err := iprot.ReadMapBegin(ctx)
		if err != nil {
			return thrift.PrependError("error reading map begin: ", err)
		}
		tMap := make(map[string]string, size)
		_elem0 := tMap
		for i := 0; i < size; i++ {
			var _key1 string
			if v, err := iprot.ReadString(ctx); err != nil {
				return thrift.PrependError("error reading field 0: ", err)
			} else {
				_key1 = v
			}
			var _val2 string
			if v, err := iprot.ReadString(ctx); err != nil {
				return thrift.PrependError("error reading field 0: ", err)
			} else {
				_val2 = v
			}
			_elem0[_key1] = _val2
		}
		if err := iprot.ReadMapEnd(ctx); err != nil {
			return thrift.PrependError("error reading map end: ", err)
		}
		p.Response = append(p.Response, _elem0)
	}
	if err := iprot.ReadListEnd(ctx); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ExtensionResponse) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "ExtensionResponse"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField1(ctx, oprot); err != nil {
			return err
		}
		if err := p.writeField2(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionResponse) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "status", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:status: ", p), err)
	}
	if err := p.Status.Write(ctx, oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Status), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:status: ", p), err)
	}
	return err
}

func (p *ExtensionResponse) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "response", thrift.LIST, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:response: ", p), err)
	}
	if err := oprot.WriteListBegin(ctx, thrift.MAP, len(p.Response)); err != nil {
		return thrift.PrependError("error writing list begin: ", err)
	}
	for _, v := range p.Response {
		if err := oprot.WriteMapBegin(ctx, thrift.STRING, thrift.STRING, len(v)); err != nil {
			return thrift.PrependError("error writing map begin: ", err)
		}
		for k, v := range v {
			if err := oprot.WriteString(ctx, string(k)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
			if err := oprot.WriteString(ctx, string(v)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
		}
		if err := oprot.WriteMapEnd(ctx); err != nil {
			return thrift.PrependError("error writing map end: ", err)
		}
	}
	if err := oprot.WriteListEnd(ctx); err != nil {
		return thrift.PrependError("error writing list end: ", err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:response: ", p), err)
	}
	return err
}

func (p *ExtensionResponse) Equals(other *ExtensionResponse) bool {
	if p == other {
		return true
	} else if p == nil || other == nil {
		return false
	}
	if !p.Status.Equals(other.Status) {
		return false
	}
	if len(p.Response) != len(other.Response) {
		return false
	}
	for i, _tgt := range p.Response {
		_src3 := other.Response[i]
		if len(_tgt) != len(_src3) {
			return false
		}
		for k, _tgt := range _tgt {
			_src4 := _src3[k]
			if _tgt != _src4 {
				return false
			}
		}
	}
	return true
}

func (p *ExtensionResponse) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionResponse(%+v)", *p)
}

// Attributes:
//  - Code
//  - Message
//  - UUID
type ExtensionException struct {
	Code    int32              `thrift:"code,1" db:"code" json:"code"`
	Message string             `thrift:"message,2" db:"message" json:"message"`
	UUID    ExtensionRouteUUID `thrift:"uuid,3" db:"uuid" json:"uuid"`
}

func NewExtensionException() *ExtensionException {
	return &ExtensionException{}
}

func (p *ExtensionException) GetCode() int32 {
	return p.Code
}

func (p *ExtensionException) GetMessage() string {
	return p.Message
}

func (p *ExtensionException) GetUUID() ExtensionRouteUUID {
	return p.UUID
}
func (p *ExtensionException) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField1(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.I64 {
				if err := p.ReadField3(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionException) ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(ctx); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Code = v
	}
	return nil
}

func (p *ExtensionException) ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(ctx); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *ExtensionException) ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(ctx); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		temp := ExtensionRouteUUID(v)
		p.UUID = temp
	}
	return nil
}

func (p *ExtensionException) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "ExtensionException"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField1(ctx, oprot); err != nil {
			return err
		}
		if err := p.writeField2(ctx, oprot); err != nil {
			return err
		}
		if err := p.writeField3(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionException) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "code", thrift.I32, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:code: ", p), err)
	}
	if err := oprot.WriteI32(ctx, int32(p.Code)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.code (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:code: ", p), err)
	}
	return err
}

func (p *ExtensionException) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "message", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:message: ", p), err)
	}
	if err := oprot.WriteString(ctx, string(p.Message)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.message (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:message: ", p), err)
	}
	return err
}

func (p *ExtensionException) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "uuid", thrift.I64, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:uuid: ", p), err)
	}
	if err := oprot.WriteI64(ctx, int64(p.UUID)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.uuid (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:uuid: ", p), err)
	}
	return err
}

func (p *ExtensionException) Equals(other *ExtensionException) bool {
	if p == other {
		return true
	} else if p == nil || other == nil {
		return false
	}
	if p.Code != other.Code {
		return false
	}
	if p.Message != other.Message {
		return false
	}
	if p.UUID != other.UUID {
		return false
	}
	return true
}

func (p *ExtensionException) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionException(%+v)", *p)
}

func (p *ExtensionException) Error() string {
	return p.String()
}

func (ExtensionException) TExceptionType() thrift.TExceptionType {
	return thrift.TExceptionTypeCompiled
}

var _ thrift.TException = (*ExtensionException)(nil)

type Extension interface {
	Ping(ctx context.Context) (_r *ExtensionStatus, _err error)
	// Parameters:
	//  - Registry
	//  - Item
	//  - Request
	Call(ctx context.Context, registry string, item string, request ExtensionPluginRequest) (_r *ExtensionResponse, _err error)
	Shutdown(ctx context.Context) (_err error)
}

type ExtensionClient struct {
	c    thrift.TClient
	meta thrift.ResponseMeta
}

func NewExtensionClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *ExtensionClient {
	return &ExtensionClient{
		c: thrift.NewTStandardClient(f.GetProtocol(t), f.GetProtocol(t)),
	}
}

func NewExtensionClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *ExtensionClient {
	return &ExtensionClient{
		c: thrift.NewTStandardClient(iprot, oprot),
	}
}

func NewExtensionClient(c thrift.TClient) *ExtensionClient {
	return &ExtensionClient{
		c: c,
	}
}

func (p *ExtensionClient) Client_() thrift.TClient {
	return p.c
}

func (p *ExtensionClient) LastResponseMeta_() thrift.ResponseMeta {
	return p.meta
}

func (p *ExtensionClient) SetLastResponseMeta_(meta thrift.ResponseMeta) {
	p.meta = meta
}

func (p *ExtensionClient) Ping(ctx context.Context) (_r *ExtensionStatus, _err error) {
	var _args5 ExtensionPingArgs
	var _result7 ExtensionPingResult
	var _meta6 thrift.ResponseMeta
	_meta6, _err = p.Client_().Call(ctx, "ping", &_args5, &_result7)
	p.SetLastResponseMeta_(_meta6)
	if _err != nil {
		return
	}
	if _ret8 := _result7.GetSuccess(); _ret8 != nil {
		return _ret8, nil
	}
	return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "ping failed: unknown result")
}

// Parameters:
//  - Registry
//  - Item
//  - Request
func (p *ExtensionClient) Call(ctx context.Context, registry string, item string, request ExtensionPluginRequest) (_r *ExtensionResponse, _err error) {
	var _args9 ExtensionCallArgs
	_args9.Registry = registry
	_args9.Item = item
	_args9.Request = request
	var _result11 ExtensionCallResult
	var _meta10 thrift.ResponseMeta
	_meta10, _err = p.Client_().Call(ctx, "call", &_args9, &_result11)
	p.SetLastResponseMeta_(_meta10)
	if _err != nil {
		return
	}
	if _ret12 := _result11.GetSuccess(); _ret12 != nil {
		return _ret12, nil
	}
	return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "call failed: unknown result")
}

func (p *ExtensionClient) Shutdown(ctx context.Context) (_err error) {
	var _args13 ExtensionShutdownArgs
	var _result15 ExtensionShutdownResult
	var _meta14 thrift.ResponseMeta
	_meta14, _err = p.Client_().Call(ctx, "shutdown", &_args13, &_result15)
	p.SetLastResponseMeta_(_meta14)
	if _err != nil {
		return
	}
	return nil
}

type ExtensionProcessor struct {
	processorMap map[string]thrift.TProcessorFunction
	handler      Extension
}

func (p *ExtensionProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) {
	p.processorMap[key] = processor
}

func (p *ExtensionProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) {
	processor, ok = p.processorMap[key]
	return processor, ok
}

func (p *ExtensionProcessor) ProcessorMap() map[string]thrift.TProcessorFunction {
	return p.processorMap
}

func NewExtensionProcessor(handler Extension) *ExtensionProcessor {

	self16 := &ExtensionProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)}
	self16.processorMap["ping"] = &extensionProcessorPing{handler: handler}
	self16.processorMap["call"] = &extensionProcessorCall{handler: handler}
	self16.processorMap["shutdown"] = &extensionProcessorShutdown{handler: handler}
	return self16
}

func (p *ExtensionProcessor) Process(ctx context.Context, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	name, _, seqId, err2 := iprot.ReadMessageBegin(ctx)
	if err2 != nil {
		return false, thrift.WrapTException(err2)
	}
	if processor, ok := p.GetProcessorFunction(name); ok {
		return processor.Process(ctx, seqId, iprot, oprot)
	}
	iprot.Skip(ctx, thrift.STRUCT)
	iprot.ReadMessageEnd(ctx)
	x17 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name)
	oprot.WriteMessageBegin(ctx, name, thrift.EXCEPTION, seqId)
	x17.Write(ctx, oprot)
	oprot.WriteMessageEnd(ctx)
	oprot.Flush(ctx)
	return false, x17

}

type extensionProcessorPing struct {
	handler Extension
}

func (p *extensionProcessorPing) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := ExtensionPingArgs{}
	var err2 error
	if err2 = args.Read(ctx, iprot); err2 != nil {
		iprot.ReadMessageEnd(ctx)
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
		oprot.WriteMessageBegin(ctx, "ping", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return false, thrift.WrapTException(err2)
	}
	iprot.ReadMessageEnd(ctx)

	tickerCancel := func() {}
	// Start a goroutine to do server side connectivity check.
	if thrift.ServerConnectivityCheckInterval > 0 {
		var cancel context.CancelFunc
		ctx, cancel = context.WithCancel(ctx)
		defer cancel()
		var tickerCtx context.Context
		tickerCtx, tickerCancel = context.WithCancel(context.Background())
		defer tickerCancel()
		go func(ctx context.Context, cancel context.CancelFunc) {
			ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
			defer ticker.Stop()
			for {
				select {
				case <-ctx.Done():
					return
				case <-ticker.C:
					if !iprot.Transport().IsOpen() {
						cancel()
						return
					}
				}
			}
		}(tickerCtx, cancel)
	}

	result := ExtensionPingResult{}
	var retval *ExtensionStatus
	if retval, err2 = p.handler.Ping(ctx); err2 != nil {
		tickerCancel()
		if err2 == thrift.ErrAbandonRequest {
			return false, thrift.WrapTException(err2)
		}
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing ping: "+err2.Error())
		oprot.WriteMessageBegin(ctx, "ping", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return true, thrift.WrapTException(err2)
	} else {
		result.Success = retval
	}
	tickerCancel()
	if err2 = oprot.WriteMessageBegin(ctx, "ping", thrift.REPLY, seqId); err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err != nil {
		return
	}
	return true, err
}

type extensionProcessorCall struct {
	handler Extension
}

func (p *extensionProcessorCall) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := ExtensionCallArgs{}
	var err2 error
	if err2 = args.Read(ctx, iprot); err2 != nil {
		iprot.ReadMessageEnd(ctx)
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
		oprot.WriteMessageBegin(ctx, "call", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return false, thrift.WrapTException(err2)
	}
	iprot.ReadMessageEnd(ctx)

	tickerCancel := func() {}
	// Start a goroutine to do server side connectivity check.
	if thrift.ServerConnectivityCheckInterval > 0 {
		var cancel context.CancelFunc
		ctx, cancel = context.WithCancel(ctx)
		defer cancel()
		var tickerCtx context.Context
		tickerCtx, tickerCancel = context.WithCancel(context.Background())
		defer tickerCancel()
		go func(ctx context.Context, cancel context.CancelFunc) {
			ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
			defer ticker.Stop()
			for {
				select {
				case <-ctx.Done():
					return
				case <-ticker.C:
					if !iprot.Transport().IsOpen() {
						cancel()
						return
					}
				}
			}
		}(tickerCtx, cancel)
	}

	result := ExtensionCallResult{}
	var retval *ExtensionResponse
	if retval, err2 = p.handler.Call(ctx, args.Registry, args.Item, args.Request); err2 != nil {
		tickerCancel()
		if err2 == thrift.ErrAbandonRequest {
			return false, thrift.WrapTException(err2)
		}
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing call: "+err2.Error())
		oprot.WriteMessageBegin(ctx, "call", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return true, thrift.WrapTException(err2)
	} else {
		result.Success = retval
	}
	tickerCancel()
	if err2 = oprot.WriteMessageBegin(ctx, "call", thrift.REPLY, seqId); err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err != nil {
		return
	}
	return true, err
}

type extensionProcessorShutdown struct {
	handler Extension
}

func (p *extensionProcessorShutdown) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := ExtensionShutdownArgs{}
	var err2 error
	if err2 = args.Read(ctx, iprot); err2 != nil {
		iprot.ReadMessageEnd(ctx)
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
		oprot.WriteMessageBegin(ctx, "shutdown", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return false, thrift.WrapTException(err2)
	}
	iprot.ReadMessageEnd(ctx)

	tickerCancel := func() {}
	// Start a goroutine to do server side connectivity check.
	if thrift.ServerConnectivityCheckInterval > 0 {
		var cancel context.CancelFunc
		ctx, cancel = context.WithCancel(ctx)
		defer cancel()
		var tickerCtx context.Context
		tickerCtx, tickerCancel = context.WithCancel(context.Background())
		defer tickerCancel()
		go func(ctx context.Context, cancel context.CancelFunc) {
			ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
			defer ticker.Stop()
			for {
				select {
				case <-ctx.Done():
					return
				case <-ticker.C:
					if !iprot.Transport().IsOpen() {
						cancel()
						return
					}
				}
			}
		}(tickerCtx, cancel)
	}

	result := ExtensionShutdownResult{}
	if err2 = p.handler.Shutdown(ctx); err2 != nil {
		tickerCancel()
		if err2 == thrift.ErrAbandonRequest {
			return false, thrift.WrapTException(err2)
		}
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing shutdown: "+err2.Error())
		oprot.WriteMessageBegin(ctx, "shutdown", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return true, thrift.WrapTException(err2)
	}
	tickerCancel()
	if err2 = oprot.WriteMessageBegin(ctx, "shutdown", thrift.REPLY, seqId); err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err != nil {
		return
	}
	return true, err
}

// HELPER FUNCTIONS AND STRUCTURES

type ExtensionPingArgs struct {
}

func NewExtensionPingArgs() *ExtensionPingArgs {
	return &ExtensionPingArgs{}
}

func (p *ExtensionPingArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		if err := iprot.Skip(ctx, fieldTypeId); err != nil {
			return err
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionPingArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "ping_args"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionPingArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionPingArgs(%+v)", *p)
}

// Attributes:
//  - Success
type ExtensionPingResult struct {
	Success *ExtensionStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewExtensionPingResult() *ExtensionPingResult {
	return &ExtensionPingResult{}
}

var ExtensionPingResult_Success_DEFAULT *ExtensionStatus

func (p *ExtensionPingResult) GetSuccess() *ExtensionStatus {
	if !p.IsSetSuccess() {
		return ExtensionPingResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExtensionPingResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *ExtensionPingResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionPingResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
	p.Success = &ExtensionStatus{}
	if err := p.Success.Read(ctx, iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *ExtensionPingResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "ping_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionPingResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(ctx, oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(ctx); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

func (p *ExtensionPingResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionPingResult(%+v)", *p)
}

// Attributes:
//  - Registry
//  - Item
//  - Request
type ExtensionCallArgs struct {
	Registry string                 `thrift:"registry,1" db:"registry" json:"registry"`
	Item     string                 `thrift:"item,2" db:"item" json:"item"`
	Request  ExtensionPluginRequest `thrift:"request,3" db:"request" json:"request"`
}

func NewExtensionCallArgs() *ExtensionCallArgs {
	return &ExtensionCallArgs{}
}

func (p *ExtensionCallArgs) GetRegistry() string {
	return p.Registry
}

func (p *ExtensionCallArgs) GetItem() string {
	return p.Item
}

func (p *ExtensionCallArgs) GetRequest() ExtensionPluginRequest {
	return p.Request
}
func (p *ExtensionCallArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.MAP {
				if err := p.ReadField3(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionCallArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(ctx); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Registry = v
	}
	return nil
}

func (p *ExtensionCallArgs) ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(ctx); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.Item = v
	}
	return nil
}

func (p *ExtensionCallArgs) ReadField3(ctx context.Context, iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin(ctx)
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(ExtensionPluginRequest, size)
	p.Request = tMap
	for i := 0; i < size; i++ {
		var _key18 string
		if v, err := iprot.ReadString(ctx); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_key18 = v
		}
		var _val19 string
		if v, err := iprot.ReadString(ctx); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_val19 = v
		}
		p.Request[_key18] = _val19
	}
	if err := iprot.ReadMapEnd(ctx); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

func (p *ExtensionCallArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "call_args"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField1(ctx, oprot); err != nil {
			return err
		}
		if err := p.writeField2(ctx, oprot); err != nil {
			return err
		}
		if err := p.writeField3(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionCallArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "registry", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:registry: ", p), err)
	}
	if err := oprot.WriteString(ctx, string(p.Registry)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.registry (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:registry: ", p), err)
	}
	return err
}

func (p *ExtensionCallArgs) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "item", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:item: ", p), err)
	}
	if err := oprot.WriteString(ctx, string(p.Item)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.item (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:item: ", p), err)
	}
	return err
}

func (p *ExtensionCallArgs) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "request", thrift.MAP, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:request: ", p), err)
	}
	if err := oprot.WriteMapBegin(ctx, thrift.STRING, thrift.STRING, len(p.Request)); err != nil {
		return thrift.PrependError("error writing map begin: ", err)
	}
	for k, v := range p.Request {
		if err := oprot.WriteString(ctx, string(k)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
		}
		if err := oprot.WriteString(ctx, string(v)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
		}
	}
	if err := oprot.WriteMapEnd(ctx); err != nil {
		return thrift.PrependError("error writing map end: ", err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:request: ", p), err)
	}
	return err
}

func (p *ExtensionCallArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionCallArgs(%+v)", *p)
}

// Attributes:
//  - Success
type ExtensionCallResult struct {
	Success *ExtensionResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewExtensionCallResult() *ExtensionCallResult {
	return &ExtensionCallResult{}
}

var ExtensionCallResult_Success_DEFAULT *ExtensionResponse

func (p *ExtensionCallResult) GetSuccess() *ExtensionResponse {
	if !p.IsSetSuccess() {
		return ExtensionCallResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExtensionCallResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *ExtensionCallResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionCallResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
	p.Success = &ExtensionResponse{}
	if err := p.Success.Read(ctx, iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *ExtensionCallResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "call_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionCallResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(ctx, oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(ctx); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

func (p *ExtensionCallResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionCallResult(%+v)", *p)
}

type ExtensionShutdownArgs struct {
}

func NewExtensionShutdownArgs() *ExtensionShutdownArgs {
	return &ExtensionShutdownArgs{}
}

func (p *ExtensionShutdownArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		if err := iprot.Skip(ctx, fieldTypeId); err != nil {
			return err
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionShutdownArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "shutdown_args"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionShutdownArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionShutdownArgs(%+v)", *p)
}

type ExtensionShutdownResult struct {
}

func NewExtensionShutdownResult() *ExtensionShutdownResult {
	return &ExtensionShutdownResult{}
}

func (p *ExtensionShutdownResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		if err := iprot.Skip(ctx, fieldTypeId); err != nil {
			return err
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionShutdownResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "shutdown_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionShutdownResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionShutdownResult(%+v)", *p)
}

type ExtensionManager interface {
	Extension

	Extensions(ctx context.Context) (_r InternalExtensionList, _err error)
	Options(ctx context.Context) (_r InternalOptionList, _err error)
	// Parameters:
	//  - Info
	//  - Registry
	RegisterExtension(ctx context.Context, info *InternalExtensionInfo, registry ExtensionRegistry) (_r *ExtensionStatus, _err error)
	// Parameters:
	//  - UUID
	DeregisterExtension(ctx context.Context, uuid ExtensionRouteUUID) (_r *ExtensionStatus, _err error)
	// Parameters:
	//  - Sql
	Query(ctx context.Context, sql string) (_r *ExtensionResponse, _err error)
	// Parameters:
	//  - Sql
	GetQueryColumns(ctx context.Context, sql string) (_r *ExtensionResponse, _err error)
}

type ExtensionManagerClient struct {
	*ExtensionClient
}

func NewExtensionManagerClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *ExtensionManagerClient {
	return &ExtensionManagerClient{ExtensionClient: NewExtensionClientFactory(t, f)}
}

func NewExtensionManagerClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *ExtensionManagerClient {
	return &ExtensionManagerClient{ExtensionClient: NewExtensionClientProtocol(t, iprot, oprot)}
}

func NewExtensionManagerClient(c thrift.TClient) *ExtensionManagerClient {
	return &ExtensionManagerClient{
		ExtensionClient: NewExtensionClient(c),
	}
}

func (p *ExtensionManagerClient) Extensions(ctx context.Context) (_r InternalExtensionList, _err error) {
	var _args28 ExtensionManagerExtensionsArgs
	var _result30 ExtensionManagerExtensionsResult
	var _meta29 thrift.ResponseMeta
	_meta29, _err = p.Client_().Call(ctx, "extensions", &_args28, &_result30)
	p.SetLastResponseMeta_(_meta29)
	if _err != nil {
		return
	}
	return _result30.GetSuccess(), nil
}

func (p *ExtensionManagerClient) Options(ctx context.Context) (_r InternalOptionList, _err error) {
	var _args31 ExtensionManagerOptionsArgs
	var _result33 ExtensionManagerOptionsResult
	var _meta32 thrift.ResponseMeta
	_meta32, _err = p.Client_().Call(ctx, "options", &_args31, &_result33)
	p.SetLastResponseMeta_(_meta32)
	if _err != nil {
		return
	}
	return _result33.GetSuccess(), nil
}

// Parameters:
//  - Info
//  - Registry
func (p *ExtensionManagerClient) RegisterExtension(ctx context.Context, info *InternalExtensionInfo, registry ExtensionRegistry) (_r *ExtensionStatus, _err error) {
	var _args34 ExtensionManagerRegisterExtensionArgs
	_args34.Info = info
	_args34.Registry = registry
	var _result36 ExtensionManagerRegisterExtensionResult
	var _meta35 thrift.ResponseMeta
	_meta35, _err = p.Client_().Call(ctx, "registerExtension", &_args34, &_result36)
	p.SetLastResponseMeta_(_meta35)
	if _err != nil {
		return
	}
	if _ret37 := _result36.GetSuccess(); _ret37 != nil {
		return _ret37, nil
	}
	return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "registerExtension failed: unknown result")
}

// Parameters:
//  - UUID
func (p *ExtensionManagerClient) DeregisterExtension(ctx context.Context, uuid ExtensionRouteUUID) (_r *ExtensionStatus, _err error) {
	var _args38 ExtensionManagerDeregisterExtensionArgs
	_args38.UUID = uuid
	var _result40 ExtensionManagerDeregisterExtensionResult
	var _meta39 thrift.ResponseMeta
	_meta39, _err = p.Client_().Call(ctx, "deregisterExtension", &_args38, &_result40)
	p.SetLastResponseMeta_(_meta39)
	if _err != nil {
		return
	}
	if _ret41 := _result40.GetSuccess(); _ret41 != nil {
		return _ret41, nil
	}
	return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "deregisterExtension failed: unknown result")
}

// Parameters:
//  - Sql
func (p *ExtensionManagerClient) Query(ctx context.Context, sql string) (_r *ExtensionResponse, _err error) {
	var _args42 ExtensionManagerQueryArgs
	_args42.Sql = sql
	var _result44 ExtensionManagerQueryResult
	var _meta43 thrift.ResponseMeta
	_meta43, _err = p.Client_().Call(ctx, "query", &_args42, &_result44)
	p.SetLastResponseMeta_(_meta43)
	if _err != nil {
		return
	}
	if _ret45 := _result44.GetSuccess(); _ret45 != nil {
		return _ret45, nil
	}
	return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "query failed: unknown result")
}

// Parameters:
//  - Sql
func (p *ExtensionManagerClient) GetQueryColumns(ctx context.Context, sql string) (_r *ExtensionResponse, _err error) {
	var _args46 ExtensionManagerGetQueryColumnsArgs
	_args46.Sql = sql
	var _result48 ExtensionManagerGetQueryColumnsResult
	var _meta47 thrift.ResponseMeta
	_meta47, _err = p.Client_().Call(ctx, "getQueryColumns", &_args46, &_result48)
	p.SetLastResponseMeta_(_meta47)
	if _err != nil {
		return
	}
	if _ret49 := _result48.GetSuccess(); _ret49 != nil {
		return _ret49, nil
	}
	return nil, thrift.NewTApplicationException(thrift.MISSING_RESULT, "getQueryColumns failed: unknown result")
}

type ExtensionManagerProcessor struct {
	*ExtensionProcessor
}

func NewExtensionManagerProcessor(handler ExtensionManager) *ExtensionManagerProcessor {
	self50 := &ExtensionManagerProcessor{NewExtensionProcessor(handler)}
	self50.AddToProcessorMap("extensions", &extensionManagerProcessorExtensions{handler: handler})
	self50.AddToProcessorMap("options", &extensionManagerProcessorOptions{handler: handler})
	self50.AddToProcessorMap("registerExtension", &extensionManagerProcessorRegisterExtension{handler: handler})
	self50.AddToProcessorMap("deregisterExtension", &extensionManagerProcessorDeregisterExtension{handler: handler})
	self50.AddToProcessorMap("query", &extensionManagerProcessorQuery{handler: handler})
	self50.AddToProcessorMap("getQueryColumns", &extensionManagerProcessorGetQueryColumns{handler: handler})
	return self50
}

type extensionManagerProcessorExtensions struct {
	handler ExtensionManager
}

func (p *extensionManagerProcessorExtensions) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := ExtensionManagerExtensionsArgs{}
	var err2 error
	if err2 = args.Read(ctx, iprot); err2 != nil {
		iprot.ReadMessageEnd(ctx)
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
		oprot.WriteMessageBegin(ctx, "extensions", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return false, thrift.WrapTException(err2)
	}
	iprot.ReadMessageEnd(ctx)

	tickerCancel := func() {}
	// Start a goroutine to do server side connectivity check.
	if thrift.ServerConnectivityCheckInterval > 0 {
		var cancel context.CancelFunc
		ctx, cancel = context.WithCancel(ctx)
		defer cancel()
		var tickerCtx context.Context
		tickerCtx, tickerCancel = context.WithCancel(context.Background())
		defer tickerCancel()
		go func(ctx context.Context, cancel context.CancelFunc) {
			ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
			defer ticker.Stop()
			for {
				select {
				case <-ctx.Done():
					return
				case <-ticker.C:
					if !iprot.Transport().IsOpen() {
						cancel()
						return
					}
				}
			}
		}(tickerCtx, cancel)
	}

	result := ExtensionManagerExtensionsResult{}
	var retval InternalExtensionList
	if retval, err2 = p.handler.Extensions(ctx); err2 != nil {
		tickerCancel()
		if err2 == thrift.ErrAbandonRequest {
			return false, thrift.WrapTException(err2)
		}
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing extensions: "+err2.Error())
		oprot.WriteMessageBegin(ctx, "extensions", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return true, thrift.WrapTException(err2)
	} else {
		result.Success = retval
	}
	tickerCancel()
	if err2 = oprot.WriteMessageBegin(ctx, "extensions", thrift.REPLY, seqId); err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err != nil {
		return
	}
	return true, err
}

type extensionManagerProcessorOptions struct {
	handler ExtensionManager
}

func (p *extensionManagerProcessorOptions) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := ExtensionManagerOptionsArgs{}
	var err2 error
	if err2 = args.Read(ctx, iprot); err2 != nil {
		iprot.ReadMessageEnd(ctx)
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
		oprot.WriteMessageBegin(ctx, "options", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return false, thrift.WrapTException(err2)
	}
	iprot.ReadMessageEnd(ctx)

	tickerCancel := func() {}
	// Start a goroutine to do server side connectivity check.
	if thrift.ServerConnectivityCheckInterval > 0 {
		var cancel context.CancelFunc
		ctx, cancel = context.WithCancel(ctx)
		defer cancel()
		var tickerCtx context.Context
		tickerCtx, tickerCancel = context.WithCancel(context.Background())
		defer tickerCancel()
		go func(ctx context.Context, cancel context.CancelFunc) {
			ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
			defer ticker.Stop()
			for {
				select {
				case <-ctx.Done():
					return
				case <-ticker.C:
					if !iprot.Transport().IsOpen() {
						cancel()
						return
					}
				}
			}
		}(tickerCtx, cancel)
	}

	result := ExtensionManagerOptionsResult{}
	var retval InternalOptionList
	if retval, err2 = p.handler.Options(ctx); err2 != nil {
		tickerCancel()
		if err2 == thrift.ErrAbandonRequest {
			return false, thrift.WrapTException(err2)
		}
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing options: "+err2.Error())
		oprot.WriteMessageBegin(ctx, "options", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return true, thrift.WrapTException(err2)
	} else {
		result.Success = retval
	}
	tickerCancel()
	if err2 = oprot.WriteMessageBegin(ctx, "options", thrift.REPLY, seqId); err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err != nil {
		return
	}
	return true, err
}

type extensionManagerProcessorRegisterExtension struct {
	handler ExtensionManager
}

func (p *extensionManagerProcessorRegisterExtension) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := ExtensionManagerRegisterExtensionArgs{}
	var err2 error
	if err2 = args.Read(ctx, iprot); err2 != nil {
		iprot.ReadMessageEnd(ctx)
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
		oprot.WriteMessageBegin(ctx, "registerExtension", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return false, thrift.WrapTException(err2)
	}
	iprot.ReadMessageEnd(ctx)

	tickerCancel := func() {}
	// Start a goroutine to do server side connectivity check.
	if thrift.ServerConnectivityCheckInterval > 0 {
		var cancel context.CancelFunc
		ctx, cancel = context.WithCancel(ctx)
		defer cancel()
		var tickerCtx context.Context
		tickerCtx, tickerCancel = context.WithCancel(context.Background())
		defer tickerCancel()
		go func(ctx context.Context, cancel context.CancelFunc) {
			ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
			defer ticker.Stop()
			for {
				select {
				case <-ctx.Done():
					return
				case <-ticker.C:
					if !iprot.Transport().IsOpen() {
						cancel()
						return
					}
				}
			}
		}(tickerCtx, cancel)
	}

	result := ExtensionManagerRegisterExtensionResult{}
	var retval *ExtensionStatus
	if retval, err2 = p.handler.RegisterExtension(ctx, args.Info, args.Registry); err2 != nil {
		tickerCancel()
		if err2 == thrift.ErrAbandonRequest {
			return false, thrift.WrapTException(err2)
		}
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing registerExtension: "+err2.Error())
		oprot.WriteMessageBegin(ctx, "registerExtension", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return true, thrift.WrapTException(err2)
	} else {
		result.Success = retval
	}
	tickerCancel()
	if err2 = oprot.WriteMessageBegin(ctx, "registerExtension", thrift.REPLY, seqId); err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err != nil {
		return
	}
	return true, err
}

type extensionManagerProcessorDeregisterExtension struct {
	handler ExtensionManager
}

func (p *extensionManagerProcessorDeregisterExtension) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := ExtensionManagerDeregisterExtensionArgs{}
	var err2 error
	if err2 = args.Read(ctx, iprot); err2 != nil {
		iprot.ReadMessageEnd(ctx)
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
		oprot.WriteMessageBegin(ctx, "deregisterExtension", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return false, thrift.WrapTException(err2)
	}
	iprot.ReadMessageEnd(ctx)

	tickerCancel := func() {}
	// Start a goroutine to do server side connectivity check.
	if thrift.ServerConnectivityCheckInterval > 0 {
		var cancel context.CancelFunc
		ctx, cancel = context.WithCancel(ctx)
		defer cancel()
		var tickerCtx context.Context
		tickerCtx, tickerCancel = context.WithCancel(context.Background())
		defer tickerCancel()
		go func(ctx context.Context, cancel context.CancelFunc) {
			ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
			defer ticker.Stop()
			for {
				select {
				case <-ctx.Done():
					return
				case <-ticker.C:
					if !iprot.Transport().IsOpen() {
						cancel()
						return
					}
				}
			}
		}(tickerCtx, cancel)
	}

	result := ExtensionManagerDeregisterExtensionResult{}
	var retval *ExtensionStatus
	if retval, err2 = p.handler.DeregisterExtension(ctx, args.UUID); err2 != nil {
		tickerCancel()
		if err2 == thrift.ErrAbandonRequest {
			return false, thrift.WrapTException(err2)
		}
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing deregisterExtension: "+err2.Error())
		oprot.WriteMessageBegin(ctx, "deregisterExtension", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return true, thrift.WrapTException(err2)
	} else {
		result.Success = retval
	}
	tickerCancel()
	if err2 = oprot.WriteMessageBegin(ctx, "deregisterExtension", thrift.REPLY, seqId); err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err != nil {
		return
	}
	return true, err
}

type extensionManagerProcessorQuery struct {
	handler ExtensionManager
}

func (p *extensionManagerProcessorQuery) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := ExtensionManagerQueryArgs{}
	var err2 error
	if err2 = args.Read(ctx, iprot); err2 != nil {
		iprot.ReadMessageEnd(ctx)
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
		oprot.WriteMessageBegin(ctx, "query", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return false, thrift.WrapTException(err2)
	}
	iprot.ReadMessageEnd(ctx)

	tickerCancel := func() {}
	// Start a goroutine to do server side connectivity check.
	if thrift.ServerConnectivityCheckInterval > 0 {
		var cancel context.CancelFunc
		ctx, cancel = context.WithCancel(ctx)
		defer cancel()
		var tickerCtx context.Context
		tickerCtx, tickerCancel = context.WithCancel(context.Background())
		defer tickerCancel()
		go func(ctx context.Context, cancel context.CancelFunc) {
			ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
			defer ticker.Stop()
			for {
				select {
				case <-ctx.Done():
					return
				case <-ticker.C:
					if !iprot.Transport().IsOpen() {
						cancel()
						return
					}
				}
			}
		}(tickerCtx, cancel)
	}

	result := ExtensionManagerQueryResult{}
	var retval *ExtensionResponse
	if retval, err2 = p.handler.Query(ctx, args.Sql); err2 != nil {
		tickerCancel()
		if err2 == thrift.ErrAbandonRequest {
			return false, thrift.WrapTException(err2)
		}
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing query: "+err2.Error())
		oprot.WriteMessageBegin(ctx, "query", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return true, thrift.WrapTException(err2)
	} else {
		result.Success = retval
	}
	tickerCancel()
	if err2 = oprot.WriteMessageBegin(ctx, "query", thrift.REPLY, seqId); err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err != nil {
		return
	}
	return true, err
}

type extensionManagerProcessorGetQueryColumns struct {
	handler ExtensionManager
}

func (p *extensionManagerProcessorGetQueryColumns) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := ExtensionManagerGetQueryColumnsArgs{}
	var err2 error
	if err2 = args.Read(ctx, iprot); err2 != nil {
		iprot.ReadMessageEnd(ctx)
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err2.Error())
		oprot.WriteMessageBegin(ctx, "getQueryColumns", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return false, thrift.WrapTException(err2)
	}
	iprot.ReadMessageEnd(ctx)

	tickerCancel := func() {}
	// Start a goroutine to do server side connectivity check.
	if thrift.ServerConnectivityCheckInterval > 0 {
		var cancel context.CancelFunc
		ctx, cancel = context.WithCancel(ctx)
		defer cancel()
		var tickerCtx context.Context
		tickerCtx, tickerCancel = context.WithCancel(context.Background())
		defer tickerCancel()
		go func(ctx context.Context, cancel context.CancelFunc) {
			ticker := time.NewTicker(thrift.ServerConnectivityCheckInterval)
			defer ticker.Stop()
			for {
				select {
				case <-ctx.Done():
					return
				case <-ticker.C:
					if !iprot.Transport().IsOpen() {
						cancel()
						return
					}
				}
			}
		}(tickerCtx, cancel)
	}

	result := ExtensionManagerGetQueryColumnsResult{}
	var retval *ExtensionResponse
	if retval, err2 = p.handler.GetQueryColumns(ctx, args.Sql); err2 != nil {
		tickerCancel()
		if err2 == thrift.ErrAbandonRequest {
			return false, thrift.WrapTException(err2)
		}
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getQueryColumns: "+err2.Error())
		oprot.WriteMessageBegin(ctx, "getQueryColumns", thrift.EXCEPTION, seqId)
		x.Write(ctx, oprot)
		oprot.WriteMessageEnd(ctx)
		oprot.Flush(ctx)
		return true, thrift.WrapTException(err2)
	} else {
		result.Success = retval
	}
	tickerCancel()
	if err2 = oprot.WriteMessageBegin(ctx, "getQueryColumns", thrift.REPLY, seqId); err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = result.Write(ctx, oprot); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.WriteMessageEnd(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err2 = oprot.Flush(ctx); err == nil && err2 != nil {
		err = thrift.WrapTException(err2)
	}
	if err != nil {
		return
	}
	return true, err
}

// HELPER FUNCTIONS AND STRUCTURES

type ExtensionManagerExtensionsArgs struct {
}

func NewExtensionManagerExtensionsArgs() *ExtensionManagerExtensionsArgs {
	return &ExtensionManagerExtensionsArgs{}
}

func (p *ExtensionManagerExtensionsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		if err := iprot.Skip(ctx, fieldTypeId); err != nil {
			return err
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionManagerExtensionsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "extensions_args"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionManagerExtensionsArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionManagerExtensionsArgs(%+v)", *p)
}

// Attributes:
//  - Success
type ExtensionManagerExtensionsResult struct {
	Success InternalExtensionList `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewExtensionManagerExtensionsResult() *ExtensionManagerExtensionsResult {
	return &ExtensionManagerExtensionsResult{}
}

var ExtensionManagerExtensionsResult_Success_DEFAULT InternalExtensionList

func (p *ExtensionManagerExtensionsResult) GetSuccess() InternalExtensionList {
	return p.Success
}
func (p *ExtensionManagerExtensionsResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *ExtensionManagerExtensionsResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.MAP {
				if err := p.ReadField0(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionManagerExtensionsResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin(ctx)
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(InternalExtensionList, size)
	p.Success = tMap
	for i := 0; i < size; i++ {
		var _key51 ExtensionRouteUUID
		if v, err := iprot.ReadI64(ctx); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			temp := ExtensionRouteUUID(v)
			_key51 = temp
		}
		_val52 := &InternalExtensionInfo{}
		if err := _val52.Read(ctx, iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _val52), err)
		}
		p.Success[_key51] = _val52
	}
	if err := iprot.ReadMapEnd(ctx); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

func (p *ExtensionManagerExtensionsResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "extensions_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionManagerExtensionsResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin(ctx, "success", thrift.MAP, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := oprot.WriteMapBegin(ctx, thrift.I64, thrift.STRUCT, len(p.Success)); err != nil {
			return thrift.PrependError("error writing map begin: ", err)
		}
		for k, v := range p.Success {
			if err := oprot.WriteI64(ctx, int64(k)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
			if err := v.Write(ctx, oprot); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
			}
		}
		if err := oprot.WriteMapEnd(ctx); err != nil {
			return thrift.PrependError("error writing map end: ", err)
		}
		if err := oprot.WriteFieldEnd(ctx); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

func (p *ExtensionManagerExtensionsResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionManagerExtensionsResult(%+v)", *p)
}

type ExtensionManagerOptionsArgs struct {
}

func NewExtensionManagerOptionsArgs() *ExtensionManagerOptionsArgs {
	return &ExtensionManagerOptionsArgs{}
}

func (p *ExtensionManagerOptionsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		if err := iprot.Skip(ctx, fieldTypeId); err != nil {
			return err
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionManagerOptionsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "options_args"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionManagerOptionsArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionManagerOptionsArgs(%+v)", *p)
}

// Attributes:
//  - Success
type ExtensionManagerOptionsResult struct {
	Success InternalOptionList `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewExtensionManagerOptionsResult() *ExtensionManagerOptionsResult {
	return &ExtensionManagerOptionsResult{}
}

var ExtensionManagerOptionsResult_Success_DEFAULT InternalOptionList

func (p *ExtensionManagerOptionsResult) GetSuccess() InternalOptionList {
	return p.Success
}
func (p *ExtensionManagerOptionsResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *ExtensionManagerOptionsResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.MAP {
				if err := p.ReadField0(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionManagerOptionsResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin(ctx)
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(InternalOptionList, size)
	p.Success = tMap
	for i := 0; i < size; i++ {
		var _key53 string
		if v, err := iprot.ReadString(ctx); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_key53 = v
		}
		_val54 := &InternalOptionInfo{}
		if err := _val54.Read(ctx, iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _val54), err)
		}
		p.Success[_key53] = _val54
	}
	if err := iprot.ReadMapEnd(ctx); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

func (p *ExtensionManagerOptionsResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "options_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionManagerOptionsResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin(ctx, "success", thrift.MAP, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := oprot.WriteMapBegin(ctx, thrift.STRING, thrift.STRUCT, len(p.Success)); err != nil {
			return thrift.PrependError("error writing map begin: ", err)
		}
		for k, v := range p.Success {
			if err := oprot.WriteString(ctx, string(k)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
			if err := v.Write(ctx, oprot); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
			}
		}
		if err := oprot.WriteMapEnd(ctx); err != nil {
			return thrift.PrependError("error writing map end: ", err)
		}
		if err := oprot.WriteFieldEnd(ctx); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

func (p *ExtensionManagerOptionsResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionManagerOptionsResult(%+v)", *p)
}

// Attributes:
//  - Info
//  - Registry
type ExtensionManagerRegisterExtensionArgs struct {
	Info     *InternalExtensionInfo `thrift:"info,1" db:"info" json:"info"`
	Registry ExtensionRegistry      `thrift:"registry,2" db:"registry" json:"registry"`
}

func NewExtensionManagerRegisterExtensionArgs() *ExtensionManagerRegisterExtensionArgs {
	return &ExtensionManagerRegisterExtensionArgs{}
}

var ExtensionManagerRegisterExtensionArgs_Info_DEFAULT *InternalExtensionInfo

func (p *ExtensionManagerRegisterExtensionArgs) GetInfo() *InternalExtensionInfo {
	if !p.IsSetInfo() {
		return ExtensionManagerRegisterExtensionArgs_Info_DEFAULT
	}
	return p.Info
}

func (p *ExtensionManagerRegisterExtensionArgs) GetRegistry() ExtensionRegistry {
	return p.Registry
}
func (p *ExtensionManagerRegisterExtensionArgs) IsSetInfo() bool {
	return p.Info != nil
}

func (p *ExtensionManagerRegisterExtensionArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.MAP {
				if err := p.ReadField2(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionManagerRegisterExtensionArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
	p.Info = &InternalExtensionInfo{}
	if err := p.Info.Read(ctx, iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Info), err)
	}
	return nil
}

func (p *ExtensionManagerRegisterExtensionArgs) ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin(ctx)
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(ExtensionRegistry, size)
	p.Registry = tMap
	for i := 0; i < size; i++ {
		var _key55 string
		if v, err := iprot.ReadString(ctx); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_key55 = v
		}
		_, _, size, err := iprot.ReadMapBegin(ctx)
		if err != nil {
			return thrift.PrependError("error reading map begin: ", err)
		}
		tMap := make(ExtensionRouteTable, size)
		_val56 := tMap
		for i := 0; i < size; i++ {
			var _key57 string
			if v, err := iprot.ReadString(ctx); err != nil {
				return thrift.PrependError("error reading field 0: ", err)
			} else {
				_key57 = v
			}
			_, size, err := iprot.ReadListBegin(ctx)
			if err != nil {
				return thrift.PrependError("error reading list begin: ", err)
			}
			tSlice := make(ExtensionPluginResponse, 0, size)
			_val58 := tSlice
			for i := 0; i < size; i++ {
				_, _, size, err := iprot.ReadMapBegin(ctx)
				if err != nil {
					return thrift.PrependError("error reading map begin: ", err)
				}
				tMap := make(map[string]string, size)
				_elem59 := tMap
				for i := 0; i < size; i++ {
					var _key60 string
					if v, err := iprot.ReadString(ctx); err != nil {
						return thrift.PrependError("error reading field 0: ", err)
					} else {
						_key60 = v
					}
					var _val61 string
					if v, err := iprot.ReadString(ctx); err != nil {
						return thrift.PrependError("error reading field 0: ", err)
					} else {
						_val61 = v
					}
					_elem59[_key60] = _val61
				}
				if err := iprot.ReadMapEnd(ctx); err != nil {
					return thrift.PrependError("error reading map end: ", err)
				}
				_val58 = append(_val58, _elem59)
			}
			if err := iprot.ReadListEnd(ctx); err != nil {
				return thrift.PrependError("error reading list end: ", err)
			}
			_val56[_key57] = _val58
		}
		if err := iprot.ReadMapEnd(ctx); err != nil {
			return thrift.PrependError("error reading map end: ", err)
		}
		p.Registry[_key55] = _val56
	}
	if err := iprot.ReadMapEnd(ctx); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

func (p *ExtensionManagerRegisterExtensionArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "registerExtension_args"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField1(ctx, oprot); err != nil {
			return err
		}
		if err := p.writeField2(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionManagerRegisterExtensionArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "info", thrift.STRUCT, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:info: ", p), err)
	}
	if err := p.Info.Write(ctx, oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Info), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:info: ", p), err)
	}
	return err
}

func (p *ExtensionManagerRegisterExtensionArgs) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "registry", thrift.MAP, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:registry: ", p), err)
	}
	if err := oprot.WriteMapBegin(ctx, thrift.STRING, thrift.MAP, len(p.Registry)); err != nil {
		return thrift.PrependError("error writing map begin: ", err)
	}
	for k, v := range p.Registry {
		if err := oprot.WriteString(ctx, string(k)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
		}
		if err := oprot.WriteMapBegin(ctx, thrift.STRING, thrift.LIST, len(v)); err != nil {
			return thrift.PrependError("error writing map begin: ", err)
		}
		for k, v := range v {
			if err := oprot.WriteString(ctx, string(k)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
			if err := oprot.WriteListBegin(ctx, thrift.MAP, len(v)); err != nil {
				return thrift.PrependError("error writing list begin: ", err)
			}
			for _, v := range v {
				if err := oprot.WriteMapBegin(ctx, thrift.STRING, thrift.STRING, len(v)); err != nil {
					return thrift.PrependError("error writing map begin: ", err)
				}
				for k, v := range v {
					if err := oprot.WriteString(ctx, string(k)); err != nil {
						return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
					}
					if err := oprot.WriteString(ctx, string(v)); err != nil {
						return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
					}
				}
				if err := oprot.WriteMapEnd(ctx); err != nil {
					return thrift.PrependError("error writing map end: ", err)
				}
			}
			if err := oprot.WriteListEnd(ctx); err != nil {
				return thrift.PrependError("error writing list end: ", err)
			}
		}
		if err := oprot.WriteMapEnd(ctx); err != nil {
			return thrift.PrependError("error writing map end: ", err)
		}
	}
	if err := oprot.WriteMapEnd(ctx); err != nil {
		return thrift.PrependError("error writing map end: ", err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:registry: ", p), err)
	}
	return err
}

func (p *ExtensionManagerRegisterExtensionArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionManagerRegisterExtensionArgs(%+v)", *p)
}

// Attributes:
//  - Success
type ExtensionManagerRegisterExtensionResult struct {
	Success *ExtensionStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewExtensionManagerRegisterExtensionResult() *ExtensionManagerRegisterExtensionResult {
	return &ExtensionManagerRegisterExtensionResult{}
}

var ExtensionManagerRegisterExtensionResult_Success_DEFAULT *ExtensionStatus

func (p *ExtensionManagerRegisterExtensionResult) GetSuccess() *ExtensionStatus {
	if !p.IsSetSuccess() {
		return ExtensionManagerRegisterExtensionResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExtensionManagerRegisterExtensionResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *ExtensionManagerRegisterExtensionResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionManagerRegisterExtensionResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
	p.Success = &ExtensionStatus{}
	if err := p.Success.Read(ctx, iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *ExtensionManagerRegisterExtensionResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "registerExtension_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionManagerRegisterExtensionResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(ctx, oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(ctx); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

func (p *ExtensionManagerRegisterExtensionResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionManagerRegisterExtensionResult(%+v)", *p)
}

// Attributes:
//  - UUID
type ExtensionManagerDeregisterExtensionArgs struct {
	UUID ExtensionRouteUUID `thrift:"uuid,1" db:"uuid" json:"uuid"`
}

func NewExtensionManagerDeregisterExtensionArgs() *ExtensionManagerDeregisterExtensionArgs {
	return &ExtensionManagerDeregisterExtensionArgs{}
}

func (p *ExtensionManagerDeregisterExtensionArgs) GetUUID() ExtensionRouteUUID {
	return p.UUID
}
func (p *ExtensionManagerDeregisterExtensionArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I64 {
				if err := p.ReadField1(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionManagerDeregisterExtensionArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(ctx); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		temp := ExtensionRouteUUID(v)
		p.UUID = temp
	}
	return nil
}

func (p *ExtensionManagerDeregisterExtensionArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "deregisterExtension_args"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField1(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionManagerDeregisterExtensionArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "uuid", thrift.I64, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:uuid: ", p), err)
	}
	if err := oprot.WriteI64(ctx, int64(p.UUID)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.uuid (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:uuid: ", p), err)
	}
	return err
}

func (p *ExtensionManagerDeregisterExtensionArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionManagerDeregisterExtensionArgs(%+v)", *p)
}

// Attributes:
//  - Success
type ExtensionManagerDeregisterExtensionResult struct {
	Success *ExtensionStatus `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewExtensionManagerDeregisterExtensionResult() *ExtensionManagerDeregisterExtensionResult {
	return &ExtensionManagerDeregisterExtensionResult{}
}

var ExtensionManagerDeregisterExtensionResult_Success_DEFAULT *ExtensionStatus

func (p *ExtensionManagerDeregisterExtensionResult) GetSuccess() *ExtensionStatus {
	if !p.IsSetSuccess() {
		return ExtensionManagerDeregisterExtensionResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExtensionManagerDeregisterExtensionResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *ExtensionManagerDeregisterExtensionResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionManagerDeregisterExtensionResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
	p.Success = &ExtensionStatus{}
	if err := p.Success.Read(ctx, iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *ExtensionManagerDeregisterExtensionResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "deregisterExtension_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionManagerDeregisterExtensionResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(ctx, oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(ctx); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

func (p *ExtensionManagerDeregisterExtensionResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionManagerDeregisterExtensionResult(%+v)", *p)
}

// Attributes:
//  - Sql
type ExtensionManagerQueryArgs struct {
	Sql string `thrift:"sql,1" db:"sql" json:"sql"`
}

func NewExtensionManagerQueryArgs() *ExtensionManagerQueryArgs {
	return &ExtensionManagerQueryArgs{}
}

func (p *ExtensionManagerQueryArgs) GetSql() string {
	return p.Sql
}
func (p *ExtensionManagerQueryArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionManagerQueryArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(ctx); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Sql = v
	}
	return nil
}

func (p *ExtensionManagerQueryArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "query_args"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField1(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionManagerQueryArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "sql", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:sql: ", p), err)
	}
	if err := oprot.WriteString(ctx, string(p.Sql)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.sql (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:sql: ", p), err)
	}
	return err
}

func (p *ExtensionManagerQueryArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionManagerQueryArgs(%+v)", *p)
}

// Attributes:
//  - Success
type ExtensionManagerQueryResult struct {
	Success *ExtensionResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewExtensionManagerQueryResult() *ExtensionManagerQueryResult {
	return &ExtensionManagerQueryResult{}
}

var ExtensionManagerQueryResult_Success_DEFAULT *ExtensionResponse

func (p *ExtensionManagerQueryResult) GetSuccess() *ExtensionResponse {
	if !p.IsSetSuccess() {
		return ExtensionManagerQueryResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExtensionManagerQueryResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *ExtensionManagerQueryResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionManagerQueryResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
	p.Success = &ExtensionResponse{}
	if err := p.Success.Read(ctx, iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *ExtensionManagerQueryResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "query_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionManagerQueryResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(ctx, oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(ctx); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

func (p *ExtensionManagerQueryResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionManagerQueryResult(%+v)", *p)
}

// Attributes:
//  - Sql
type ExtensionManagerGetQueryColumnsArgs struct {
	Sql string `thrift:"sql,1" db:"sql" json:"sql"`
}

func NewExtensionManagerGetQueryColumnsArgs() *ExtensionManagerGetQueryColumnsArgs {
	return &ExtensionManagerGetQueryColumnsArgs{}
}

func (p *ExtensionManagerGetQueryColumnsArgs) GetSql() string {
	return p.Sql
}
func (p *ExtensionManagerGetQueryColumnsArgs) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField1(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionManagerGetQueryColumnsArgs) ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(ctx); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Sql = v
	}
	return nil
}

func (p *ExtensionManagerGetQueryColumnsArgs) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "getQueryColumns_args"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField1(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionManagerGetQueryColumnsArgs) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin(ctx, "sql", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:sql: ", p), err)
	}
	if err := oprot.WriteString(ctx, string(p.Sql)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.sql (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:sql: ", p), err)
	}
	return err
}

func (p *ExtensionManagerGetQueryColumnsArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionManagerGetQueryColumnsArgs(%+v)", *p)
}

// Attributes:
//  - Success
type ExtensionManagerGetQueryColumnsResult struct {
	Success *ExtensionResponse `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewExtensionManagerGetQueryColumnsResult() *ExtensionManagerGetQueryColumnsResult {
	return &ExtensionManagerGetQueryColumnsResult{}
}

var ExtensionManagerGetQueryColumnsResult_Success_DEFAULT *ExtensionResponse

func (p *ExtensionManagerGetQueryColumnsResult) GetSuccess() *ExtensionResponse {
	if !p.IsSetSuccess() {
		return ExtensionManagerGetQueryColumnsResult_Success_DEFAULT
	}
	return p.Success
}
func (p *ExtensionManagerGetQueryColumnsResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *ExtensionManagerGetQueryColumnsResult) Read(ctx context.Context, iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField0(ctx, iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *ExtensionManagerGetQueryColumnsResult) ReadField0(ctx context.Context, iprot thrift.TProtocol) error {
	p.Success = &ExtensionResponse{}
	if err := p.Success.Read(ctx, iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
	}
	return nil
}

func (p *ExtensionManagerGetQueryColumnsResult) Write(ctx context.Context, oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin(ctx, "getQueryColumns_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(ctx, oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *ExtensionManagerGetQueryColumnsResult) writeField0(ctx context.Context, oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin(ctx, "success", thrift.STRUCT, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := p.Success.Write(ctx, oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), err)
		}
		if err := oprot.WriteFieldEnd(ctx); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

func (p *ExtensionManagerGetQueryColumnsResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("ExtensionManagerGetQueryColumnsResult(%+v)", *p)
}


================================================
FILE: go.mod
================================================
module github.com/osquery/osquery-go

require (
	github.com/Microsoft/go-winio v0.6.2
	github.com/apache/thrift v0.20.0
	github.com/pkg/errors v0.8.0
	github.com/stretchr/testify v1.8.3
	go.opentelemetry.io/otel v1.16.0
	go.opentelemetry.io/otel/trace v1.16.0
)

require (
	github.com/davecgh/go-spew v1.1.1 // indirect
	github.com/go-logr/logr v1.2.4 // indirect
	github.com/go-logr/stdr v1.2.2 // indirect
	github.com/pmezard/go-difflib v1.0.0 // indirect
	go.opentelemetry.io/otel/metric v1.16.0 // indirect
	golang.org/x/sys v0.25.0 // indirect
	gopkg.in/yaml.v3 v3.0.1 // indirect
)

go 1.26


================================================
FILE: go.sum
================================================
github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
github.com/apache/thrift v0.20.0 h1:631+KvYbsBZxmuJjYwhezVsrfc/TbqtZV4QcxOX1fOI=
github.com/apache/thrift v0.20.0/go.mod h1:hOk1BQqcp2OLzGsyVXdfMk7YFlMxK3aoEVhjD06QhB8=
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/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
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/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
go.opentelemetry.io/otel v1.16.0 h1:Z7GVAX/UkAXPKsy94IU+i6thsQS4nb7LviLpnaNeW8s=
go.opentelemetry.io/otel v1.16.0/go.mod h1:vl0h9NUa1D5s1nv3A5vZOYWn8av4K8Ml6JDeHrT/bx4=
go.opentelemetry.io/otel/metric v1.16.0 h1:RbrpwVG1Hfv85LgnZ7+txXioPDoh6EdbZHo26Q3hqOo=
go.opentelemetry.io/otel/metric v1.16.0/go.mod h1:QE47cpOmkwipPiefDwo2wDzwJrlfxxNYodqc4xnGCo4=
go.opentelemetry.io/otel/trace v1.16.0 h1:8JRpaObFoW0pxuVPapkgH8UhHQj+bJW8jJsCZEu5MQs=
go.opentelemetry.io/otel/trace v1.16.0/go.mod h1:Yt9vYq1SdNz3xdjZZK7wcXv1qv2pwLkqr2QVwea0ef0=
golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=


================================================
FILE: locker.go
================================================
package osquery

import (
	"context"
	"fmt"
	"time"
)

// locker uses go channels to create a lock mechanism. We use channels, and not the more common mutexes, because the
// latter cannot be interrupted. This allows callers to timeout without blocking on the mutex.
//
// We need _some_ lock mechanism because the underlying thrift socket only allows a single actor at a time. If two
// goroutines are trying to use the socket at the same time, they will get protocol errors.
type locker struct {
	c              chan struct{}
	defaultTimeout time.Duration // Default wait time is used if context does not have a deadline
	maxWait        time.Duration // Maximum time something is allowed to wait
}

func NewLocker(defaultTimeout time.Duration, maxWait time.Duration) *locker {
	return &locker{
		c:              make(chan struct{}, 1),
		defaultTimeout: defaultTimeout,
		maxWait:        maxWait,
	}
}

// Lock attempts to lock l. It will wait for the shorter of (ctx deadline | defaultTimeout) and maxWait.
func (l *locker) Lock(ctx context.Context) error {
	// Assume most callers have set a deadline on the context, and start this as being the max allowed wait time
	wait := l.maxWait
	timeoutError := "timeout after maximum of %s"

	// If the caller has not set a deadline, use the default.
	if _, ok := ctx.Deadline(); !ok {
		wait = l.defaultTimeout
		timeoutError = "timeout after %s"

	}

	timeout := time.NewTimer(wait)
	defer timeout.Stop()

	// Block until we get the lock, the context is canceled, or we time out.
	select {
	case l.c <- struct{}{}:
		// lock acquired
		return nil
	case <-ctx.Done():
		// context has been canceled
		return fmt.Errorf("context canceled: %w", ctx.Err())
	case <-timeout.C:
		// timed out
		return fmt.Errorf(timeoutError, wait)
	}
}

// Unlock unlocks l. It is a runtime error to unlock an unlocked locker.
func (l *locker) Unlock() {
	select {
	case <-l.c:
		return
	default:
		// Calling Unlock on an unlocked mutex is a fatal error. We mirror that behavior here.
		panic("unlock of unlocked locker")
	}

}


================================================
FILE: locker_test.go
================================================
package osquery

import (
	"context"
	"math/rand"
	"sync"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestLocker(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name                   string
		sleepTime              time.Duration
		ctxTimeout             time.Duration
		parallelism            int
		expectedSuccessesRange [2]int
		expectedErrorRange     [2]int
		expectedErrors         []string
	}{
		{
			name:                   "basic",
			sleepTime:              1 * time.Millisecond,
			ctxTimeout:             10 * time.Millisecond,
			parallelism:            5,
			expectedSuccessesRange: [2]int{5, 5},
		},
		{
			name:                   "some finishers",
			sleepTime:              4 * time.Millisecond,
			ctxTimeout:             10 * time.Millisecond,
			parallelism:            5,
			expectedSuccessesRange: [2]int{2, 3},
			expectedErrorRange:     [2]int{2, 3},
		},
		{
			name:                   "sleep longer than context",
			sleepTime:              150 * time.Millisecond,
			ctxTimeout:             10 * time.Millisecond,
			parallelism:            5,
			expectedSuccessesRange: [2]int{1, 1},
			expectedErrorRange:     [2]int{4, 4},
			expectedErrors:         []string{"context canceled: context deadline exceeded"},
		},
		{
			name:                   "no ctx fall back to default timeout",
			sleepTime:              150 * time.Millisecond,
			parallelism:            5,
			expectedSuccessesRange: [2]int{1, 1},
			expectedErrorRange:     [2]int{4, 4},
			expectedErrors:         []string{"timeout after 100ms"},
		},
		{
			name:                   "ctx longer than maxwait",
			sleepTime:              250 * time.Millisecond,
			ctxTimeout:             10 * time.Second,
			parallelism:            5,
			expectedSuccessesRange: [2]int{1, 1},
			expectedErrorRange:     [2]int{4, 4},
			expectedErrors:         []string{"timeout after maximum of 200ms"},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			doer := NewThingDoer()

			wait := sync.WaitGroup{}
			for i := 0; i < tt.parallelism; i++ {
				wait.Add(1)
				go func() {
					defer wait.Done()

					ctx := context.TODO()
					if tt.ctxTimeout != 0 {
						var cancel context.CancelFunc
						ctx, cancel = context.WithTimeout(ctx, tt.ctxTimeout)
						defer cancel()
					}

					_ = doer.Once(ctx, tt.sleepTime)
				}()
			}

			wait.Wait()

			assertBetween(t, doer.Successes, tt.expectedSuccessesRange, "success count")
			assertBetween(t, len(doer.Errors), tt.expectedErrorRange, "error count")

			for _, errMsg := range tt.expectedErrors {
				assert.Contains(t, doer.Errors, errMsg)
			}
		})
	}
}

func TestNeedlessUnlock(t *testing.T) {
	t.Parallel()

	locker := NewLocker(100*time.Millisecond, 200*time.Millisecond)
	assert.Panics(t, func() { locker.Unlock() })
}

func TestDoubleUnlock(t *testing.T) {
	t.Parallel()

	locker := NewLocker(100*time.Millisecond, 200*time.Millisecond)

	require.NoError(t, locker.Lock(context.TODO()))
	assert.NotPanics(t, func() { locker.Unlock() })
	assert.Panics(t, func() { locker.Unlock() })
}

func TestLockerChaos(t *testing.T) {
	t.Parallel()

	doer := NewThingDoer()

	wait := sync.WaitGroup{}
	for i := 0; i < 100; i++ {
		wait.Add(1)
		go func() {
			defer wait.Done()

			ctx := context.TODO()
			if rand.Intn(100) > 20 {
				var cancel context.CancelFunc
				ctx, cancel = context.WithTimeout(ctx, time.Duration(rand.Intn(500))*time.Millisecond)
				defer cancel()
			}

			_ = doer.Once(ctx, time.Duration(rand.Intn(100))*time.Millisecond)
		}()
	}
	wait.Wait()

	assert.GreaterOrEqual(t, doer.Successes, 1, "successes")
	assert.GreaterOrEqual(t, len(doer.Errors), 1, "failures")

}

type thingDoer struct {
	locker    *locker
	Successes int
	Errors    []string
	errMu     sync.Mutex
}

func NewThingDoer() *thingDoer {
	return &thingDoer{
		locker: NewLocker(100*time.Millisecond, 200*time.Millisecond),
		Errors: make([]string, 0),
	}
}

func (doer *thingDoer) Once(ctx context.Context, d time.Duration) error {
	if err := doer.locker.Lock(ctx); err != nil {
		doer.errMu.Lock()
		defer doer.errMu.Unlock()

		doer.Errors = append(doer.Errors, err.Error())
		return err
	}
	defer doer.locker.Unlock()

	// Note that we don't need to protect the success path with a mutext, that is the point of locker
	time.Sleep(d)
	doer.Successes += 1

	return nil
}

// assertBetween is a wrapper over assert.GreateOrEqual and assert.LessOrEqual. We use it to provide small ranges for
// expected test results. This is because GitHub Actions is prone to weird timing issues and slowdowns
func assertBetween(t *testing.T, actual int, r [2]int, msg string) {
	assert.GreaterOrEqual(t, actual, r[0], msg)
	assert.LessOrEqual(t, actual, r[1], msg)
}


================================================
FILE: mock/osquery.go
================================================
// Automatically generated by mockimpl. DO NOT EDIT!

package mock

import (
	"context"

	"github.com/osquery/osquery-go/gen/osquery"
)

var _ osquery.ExtensionManager = (*ExtensionManager)(nil)

type CloseFunc func()

type PingFunc func(ctx context.Context) (*osquery.ExtensionStatus, error)

type CallFunc func(ctx context.Context, registry string, item string, req osquery.ExtensionPluginRequest) (*osquery.ExtensionResponse, error)

type ShutdownFunc func(ctx context.Context) error

type ExtensionsFunc func(ctx context.Context) (osquery.InternalExtensionList, error)

type RegisterExtensionFunc func(ctx context.Context, info *osquery.InternalExtensionInfo, registry osquery.ExtensionRegistry) (*osquery.ExtensionStatus, error)

type DeregisterExtensionFunc func(ctx context.Context, uuid osquery.ExtensionRouteUUID) (*osquery.ExtensionStatus, error)

type OptionsFunc func(ctx context.Context) (osquery.InternalOptionList, error)

type QueryFunc func(ctx context.Context, sql string) (*osquery.ExtensionResponse, error)

type GetQueryColumnsFunc func(ctx context.Context, sql string) (*osquery.ExtensionResponse, error)

type ExtensionManager struct {
	CloseFunc        CloseFunc
	CloseFuncInvoked bool

	PingFunc        PingFunc
	PingFuncInvoked bool

	CallFunc        CallFunc
	CallFuncInvoked bool

	ShutdownFunc        ShutdownFunc
	ShutdownFuncInvoked bool

	ExtensionsFunc        ExtensionsFunc
	ExtensionsFuncInvoked bool

	RegisterExtensionFunc        RegisterExtensionFunc
	RegisterExtensionFuncInvoked bool

	DeregisterExtensionFunc        DeregisterExtensionFunc
	DeregisterExtensionFuncInvoked bool

	OptionsFunc        OptionsFunc
	OptionsFuncInvoked bool

	QueryFunc        QueryFunc
	QueryFuncInvoked bool

	GetQueryColumnsFunc        GetQueryColumnsFunc
	GetQueryColumnsFuncInvoked bool
}

func (m *ExtensionManager) Close() {
	m.CloseFuncInvoked = true
	m.CloseFunc()
}

func (m *ExtensionManager) Ping(ctx context.Context) (*osquery.ExtensionStatus, error) {
	m.PingFuncInvoked = true
	return m.PingFunc(ctx)
}

func (m *ExtensionManager) Call(ctx context.Context, registry string, item string, req osquery.ExtensionPluginRequest) (*osquery.ExtensionResponse, error) {
	m.CallFuncInvoked = true
	return m.CallFunc(ctx, registry, item, req)
}

func (m *ExtensionManager) Shutdown(ctx context.Context) error {
	m.ShutdownFuncInvoked = true
	return m.ShutdownFunc(ctx)
}

func (m *ExtensionManager) Extensions(ctx context.Context) (osquery.InternalExtensionList, error) {
	m.ExtensionsFuncInvoked = true
	return m.ExtensionsFunc(ctx)
}

func (m *ExtensionManager) RegisterExtension(ctx context.Context, info *osquery.InternalExtensionInfo, registry osquery.ExtensionRegistry) (*osquery.ExtensionStatus, error) {
	m.RegisterExtensionFuncInvoked = true
	return m.RegisterExtensionFunc(ctx, info, registry)
}

func (m *ExtensionManager) DeregisterExtension(ctx context.Context, uuid osquery.ExtensionRouteUUID) (*osquery.ExtensionStatus, error) {
	m.DeregisterExtensionFuncInvoked = true
	return m.DeregisterExtensionFunc(ctx, uuid)
}

func (m *ExtensionManager) Options(ctx context.Context) (osquery.InternalOptionList, error) {
	m.OptionsFuncInvoked = true
	return m.OptionsFunc(ctx)
}

func (m *ExtensionManager) Query(ctx context.Context, sql string) (*osquery.ExtensionResponse, error) {
	m.QueryFuncInvoked = true
	return m.QueryFunc(ctx, sql)
}

func (m *ExtensionManager) GetQueryColumns(ctx context.Context, sql string) (*osquery.ExtensionResponse, error) {
	m.GetQueryColumnsFuncInvoked = true
	return m.GetQueryColumnsFunc(ctx, sql)
}


================================================
FILE: mock_manager.go
================================================
// Automatically generated by mockimpl. DO NOT EDIT!

package osquery

import "github.com/osquery/osquery-go/gen/osquery"

var _ ExtensionManager = (*MockExtensionManager)(nil)

type CloseFunc func()

type PingFunc func() (*osquery.ExtensionStatus, error)

type CallFunc func(registry string, item string, req osquery.ExtensionPluginRequest) (*osquery.ExtensionResponse, error)

type ExtensionsFunc func() (osquery.InternalExtensionList, error)

type RegisterExtensionFunc func(info *osquery.InternalExtensionInfo, registry osquery.ExtensionRegistry) (*osquery.ExtensionStatus, error)

type DeregisterExtensionFunc func(uuid osquery.ExtensionRouteUUID) (*osquery.ExtensionStatus, error)

type OptionsFunc func() (osquery.InternalOptionList, error)

type QueryFunc func(sql string) (*osquery.ExtensionResponse, error)

type GetQueryColumnsFunc func(sql string) (*osquery.ExtensionResponse, error)

type MockExtensionManager struct {
	CloseFunc        CloseFunc
	CloseFuncInvoked bool

	PingFunc        PingFunc
	PingFuncInvoked bool

	CallFunc        CallFunc
	CallFuncInvoked bool

	ExtensionsFunc        ExtensionsFunc
	ExtensionsFuncInvoked bool

	RegisterExtensionFunc        RegisterExtensionFunc
	RegisterExtensionFuncInvoked bool

	DeRegisterExtensionFunc        DeregisterExtensionFunc
	DeRegisterExtensionFuncInvoked bool

	OptionsFunc        OptionsFunc
	OptionsFuncInvoked bool

	QueryFunc        QueryFunc
	QueryFuncInvoked bool

	GetQueryColumnsFunc        GetQueryColumnsFunc
	GetQueryColumnsFuncInvoked bool
}

func (m *MockExtensionManager) Close() {
	m.CloseFuncInvoked = true
	m.CloseFunc()
}

func (m *MockExtensionManager) Ping() (*osquery.ExtensionStatus, error) {
	m.PingFuncInvoked = true
	return m.PingFunc()
}

func (m *MockExtensionManager) Call(registry string, item string, req osquery.ExtensionPluginRequest) (*osquery.ExtensionResponse, error) {
	m.CallFuncInvoked = true
	return m.CallFunc(registry, item, req)
}

func (m *MockExtensionManager) Extensions() (osquery.InternalExtensionList, error) {
	m.ExtensionsFuncInvoked = true
	return m.ExtensionsFunc()
}

func (m *MockExtensionManager) RegisterExtension(info *osquery.InternalExtensionInfo, registry osquery.ExtensionRegistry) (*osquery.ExtensionStatus, error) {
	m.RegisterExtensionFuncInvoked = true
	return m.RegisterExtensionFunc(info, registry)
}

func (m *MockExtensionManager) DeregisterExtension(uuid osquery.ExtensionRouteUUID) (*osquery.ExtensionStatus, error) {
	m.DeRegisterExtensionFuncInvoked = true
	return m.DeRegisterExtensionFunc(uuid)
}

func (m *MockExtensionManager) Options() (osquery.InternalOptionList, error) {
	m.OptionsFuncInvoked = true
	return m.OptionsFunc()
}

func (m *MockExtensionManager) Query(sql string) (*osquery.ExtensionResponse, error) {
	m.QueryFuncInvoked = true
	return m.QueryFunc(sql)
}

func (m *MockExtensionManager) GetQueryColumns(sql string) (*osquery.ExtensionResponse, error) {
	m.GetQueryColumnsFuncInvoked = true
	return m.GetQueryColumnsFunc(sql)
}


================================================
FILE: osquery.thrift
================================================
namespace cpp osquery.extensions

/// Registry operations use a registry name, plugin name, request/response.
typedef map<string, string> ExtensionPluginRequest
typedef list<map<string, string>> ExtensionPluginResponse

/// Extensions should request osquery options to set active registries and
/// bootstrap any config/logger plugins.
struct InternalOptionInfo {
  1:string value,
  2:string default_value,
  3:string type,
}

/// Each option (CLI flag) has a unique name.
typedef map<string, InternalOptionInfo> InternalOptionList

/// When communicating extension metadata, use a thrift-internal structure.
struct InternalExtensionInfo {
  1:string name,
  2:string version,
  3:string sdk_version,
  4:string min_sdk_version,
}

/// Unique ID for each extension.
typedef i64 ExtensionRouteUUID
/// A map from each plugin name to its optional route information.
typedef map<string, ExtensionPluginResponse> ExtensionRouteTable
/// A map from each registry name.
typedef map<string, ExtensionRouteTable> ExtensionRegistry
/// A map from each extension's unique ID to its map of registries.
typedef map<ExtensionRouteUUID, InternalExtensionInfo> InternalExtensionList

enum ExtensionCode {
  EXT_SUCCESS = 0,
  EXT_FAILED = 1,
  EXT_FATAL = 2,
}

/// Most communication uses the Status return type.
struct ExtensionStatus {
  1:i32 code,
  2:string message,
  /// Add a thrift Status parameter identifying the request/response.
  3:ExtensionRouteUUID uuid,
}

struct ExtensionResponse {
  1:ExtensionStatus status,
  2:ExtensionPluginResponse response,
}

exception ExtensionException {
  1:i32 code,
  2:string message,
  3:ExtensionRouteUUID uuid,
}

service Extension {
  /// Ping to/from an extension and extension manager for metadata.
  ExtensionStatus ping(),
  /// Call an extension (or core) registry plugin.
  ExtensionResponse call(
    /// The registry name (e.g., config, logger, table, etc).
    1:string registry,
    /// The registry item name (plugin name).
    2:string item,
    /// The thrift-equivilent of an osquery::PluginRequest.
    3:ExtensionPluginRequest request),
  /// Request that an extension shutdown (does not apply to managers).
  void shutdown(),
}

/// The extension manager is run by the osquery core process.
service ExtensionManager extends Extension {
  /// Return the list of active registered extensions.
  InternalExtensionList extensions(),
  /// Return the list of bootstrap or configuration options.
  InternalOptionList options(),
  /// The API endpoint used by an extension to register its plugins.
  ExtensionStatus registerExtension(
    1:InternalExtensionInfo info,
    2:ExtensionRegistry registry),
  ExtensionStatus deregisterExtension(
    1:ExtensionRouteUUID uuid,
  ),
  /// Allow an extension to query using an SQL string.
  ExtensionResponse query(
    1:string sql,
  ),
  /// Allow an extension to introspect into SQL used in a parsed query.
  ExtensionResponse getQueryColumns(
    1:string sql,
  ),
}


================================================
FILE: plugin/config/config.go
================================================
// Package config creates an osquery configuration plugin.
//
// See https://osquery.readthedocs.io/en/latest/development/config-plugins/ for more.
package config

import (
	"context"

	"github.com/osquery/osquery-go/gen/osquery"
	"github.com/osquery/osquery-go/traces"
)

// GenerateConfigsFunc returns the configurations generated by this plugin.
// The returned map should use the source name as key, and the config
// JSON as values. The context argument can optionally be used for
// cancellation in long-running operations.
type GenerateConfigsFunc func(ctx context.Context) (map[string]string, error)

// Plugin is an osquery configuration plugin. Plugin implements the OsqueryPlugin
// interface.
type Plugin struct {
	name     string
	generate GenerateConfigsFunc
}

// NewConfigPlugin takes a value that implements ConfigPlugin and wraps it with
// the appropriate methods to satisfy the OsqueryPlugin interface. Use this to
// easily create configuration plugins.
func NewPlugin(name string, fn GenerateConfigsFunc) *Plugin {
	return &Plugin{name: name, generate: fn}
}

func (t *Plugin) Name() string {
	return t.name
}

// Registry name for config plugins
const configRegistryName = "config"

func (t *Plugin) RegistryName() string {
	return configRegistryName
}

func (t *Plugin) Routes() osquery.ExtensionPluginResponse {
	return osquery.ExtensionPluginResponse{}
}

func (t *Plugin) Ping() osquery.ExtensionStatus {
	return osquery.ExtensionStatus{Code: 0, Message: "OK"}
}

// Key that the request method is stored under
const requestActionKey = "action"

// Action value used when config is requested
const genConfigAction = "genConfig"

func (t *Plugin) Call(ctx context.Context, request osquery.ExtensionPluginRequest) osquery.ExtensionResponse {
	ctx, span := traces.StartSpan(ctx, "Config.Call", "action", request[requestActionKey])
	defer span.End()

	switch request[requestActionKey] {
	case genConfigAction:
		configs, err := t.generate(ctx)
		if err != nil {
			return osquery.ExtensionResponse{
				Status: &osquery.ExtensionStatus{
					Code:    1,
					Message: "error getting config: " + err.Error(),
				},
			}
		}

		return osquery.ExtensionResponse{
			Status:   &osquery.ExtensionStatus{Code: 0, Message: "OK"},
			Response: osquery.ExtensionPluginResponse{configs},
		}

	default:
		return osquery.ExtensionResponse{
			Status: &osquery.ExtensionStatus{
				Code:    1,
				Message: "unknown action: " + request["action"],
			},
		}
	}

}

func (t *Plugin) Shutdown() {}


================================================
FILE: plugin/config/config_test.go
================================================
package config

import (
	"context"
	"errors"
	"testing"

	"github.com/osquery/osquery-go/gen/osquery"
	"github.com/stretchr/testify/assert"
)

var StatusOK = osquery.ExtensionStatus{Code: 0, Message: "OK"}

func TestConfigPlugin(t *testing.T) {
	var called bool
	plugin := NewPlugin("mock", func(context.Context) (map[string]string, error) {
		called = true
		return map[string]string{
			"conf1": "foobar",
		}, nil
	})

	// Basic methods
	assert.Equal(t, "config", plugin.RegistryName())
	assert.Equal(t, "mock", plugin.Name())
	assert.Equal(t, StatusOK, plugin.Ping())
	assert.Equal(t, osquery.ExtensionPluginResponse{}, plugin.Routes())

	// Call with good action
	resp := plugin.Call(context.Background(), osquery.ExtensionPluginRequest{"action": "genConfig"})
	assert.True(t, called)
	assert.Equal(t, &StatusOK, resp.Status)
	assert.Equal(t, osquery.ExtensionPluginResponse{{"conf1": "foobar"}}, resp.Response)
}

func TestConfigPluginErrors(t *testing.T) {
	var called bool
	plugin := NewPlugin("mock", func(context.Context) (map[string]string, error) {
		called = true
		return nil, errors.New("foobar")
	})

	// Call with bad actions
	assert.Equal(t, int32(1), plugin.Call(context.Background(), osquery.ExtensionPluginRequest{}).Status.Code)
	assert.False(t, called)
	assert.Equal(t, int32(1), plugin.Call(context.Background(), osquery.ExtensionPluginRequest{"action": "bad"}).Status.Code)
	assert.False(t, called)

	// Call with good action but generate fails
	resp := plugin.Call(context.Background(), osquery.ExtensionPluginRequest{"action": "genConfig"})
	assert.True(t, called)
	assert.Equal(t, int32(1), resp.Status.Code)
	assert.Equal(t, "error getting config: foobar", resp.Status.Message)
}


================================================
FILE: plugin/distributed/distributed.go
================================================
// Package distributed creates an osquery distributed query plugin.
package distributed

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
	"strconv"
	"strings"

	"github.com/osquery/osquery-go/gen/osquery"
	"github.com/osquery/osquery-go/traces"
)

// GetQueriesResult contains the information about which queries the
// distributed system should run.
type GetQueriesResult struct {
	// Queries is a map from query name to query SQL
	Queries map[string]string `json:"queries"`
	// Discovery is used for "discovery" queries in the distributed
	// system. When used, discovery queries should be specified with query
	// name as the key and the discover query SQL as the value. If this is
	// nonempty, only queries for which the associated discovery query
	// returns results will be run in osquery.
	Discovery map[string]string `json:"discovery,omitempty"`
	// AccelerateSeconds can be specified to have "accelerated" checkins
	// for a given number of seconds after this checkin. Currently this
	// means that checkins will occur every 5 seconds.
	AccelerateSeconds int `json:"accelerate,omitempty"`
}

// GetQueriesFunc returns the queries that should be executed.
// The returned map should include the query name as the keys, and the query
// text as values. Results will be returned corresponding to the provided name.
// The context argument can optionally be used for cancellation in long-running
// operations.
type GetQueriesFunc func(ctx context.Context) (*GetQueriesResult, error)

// Result contains the status and results for a distributed query.
type Result struct {
	// QueryName is the name that was originally provided for the query.
	QueryName string `json:"query_name"`
	// Status is an integer status code for the query execution (0 = OK)
	Status int `json:"status"`
	// Rows is the result rows of the query.
	Rows []map[string]string `json:"rows"`
	// QueryStats are the stats about the execution of the given query
	QueryStats *Stats `json:"stats"`
	// Message is the message string indicating the status of the query
	Message string `json:"message"`
}

// WriteResultsFunc writes the results of the executed distributed queries. The
// query results will be serialized JSON in the results map with the query name
// as the key.
type WriteResultsFunc func(ctx context.Context, results []Result) error

// Plugin is an osquery configuration plugin. Plugin implements the OsqueryPlugin
// interface.
type Plugin struct {
	name         string
	getQueries   GetQueriesFunc
	writeResults WriteResultsFunc
}

// NewPlugin takes the distributed query functions and returns a struct
// implementing the OsqueryPlugin interface. Use this to wrap the appropriate
// functions into an osquery plugin.
func NewPlugin(name string, getQueries GetQueriesFunc, writeResults WriteResultsFunc) *Plugin {
	return &Plugin{name: name, getQueries: getQueries, writeResults: writeResults}
}

func (t *Plugin) Name() string {
	return t.name
}

// Registry name for distributed plugins
const distributedRegistryName = "distributed"

func (t *Plugin) RegistryName() string {
	return distributedRegistryName
}

func (t *Plugin) Routes() osquery.ExtensionPluginResponse {
	return osquery.ExtensionPluginResponse{}
}

func (t *Plugin) Ping() osquery.ExtensionStatus {
	return osquery.ExtensionStatus{Code: 0, Message: "OK"}
}

// Key that the request method is stored under
const requestActionKey = "action"

// Action value used when queries are requested
const getQueriesAction = "getQueries"

// Action value used when results are written
const writeResultsAction = "writeResults"

// Key that results are stored under
const requestResultKey = "results"

// OsqueryInt handles unmarshaling integers in noncanonical osquery json.
type OsqueryInt int

// UnmarshalJSON marshals a json string that is convertable to an int, for
// example "234" -> 234.
func (oi *OsqueryInt) UnmarshalJSON(buff []byte) error {
	s := string(buff)
	if strings.Contains(s, `"`) {
		unquoted, err := strconv.Unquote(s)
		if err != nil {
			return &json.UnmarshalTypeError{
				Value:  string(buff),
				Type:   reflect.TypeOf(oi),
				Struct: "statuses",
			}
		}
		s = unquoted
	}

	if len(s) == 0 {
		*oi = OsqueryInt(0)
		return nil
	}

	parsedInt, err := strconv.ParseInt(s, 10, 32)
	if err != nil {
		return &json.UnmarshalTypeError{
			Value:  string(buff),
			Type:   reflect.TypeOf(oi),
			Struct: "statuses",
		}
	}

	*oi = OsqueryInt(parsedInt)
	return nil
}

// ResultsStruct is used for unmarshalling the results passed from osquery.
type ResultsStruct struct {
	Queries  map[string][]map[string]string `json:"queries"`
	Statuses map[string]OsqueryInt          `json:"statuses"`
	Stats    map[string]Stats               `json:"stats"`
	Messages map[string]string              `json:"messages"`
}

// Stats holds performance stats about the execution of a given query.
type Stats struct {
	WallTimeMs OsqueryInt `json:"wall_time_ms"`
	UserTime   OsqueryInt `json:"user_time"`
	SystemTime OsqueryInt `json:"system_time"`
	Memory     OsqueryInt `json:"memory"`
}

// UnmarshalJSON turns structurally inconsistent osquery json into a ResultsStruct.
func (rs *ResultsStruct) UnmarshalJSON(buff []byte) error {
	emptyRow := []map[string]string{}
	rs.Queries = make(map[string][]map[string]string)
	rs.Statuses = make(map[string]OsqueryInt)
	rs.Messages = make(map[string]string)
	// Queries can be []map[string]string OR an empty string
	// so we need to deal with an interface to accommodate two types
	intermediate := struct {
		Queries  map[string]interface{} `json:"queries"`
		Statuses map[string]OsqueryInt  `json:"statuses"`
		Stats    map[string]Stats       `json:"stats"`
		Messages map[string]string      `json:"messages"`
	}{}
	if err := json.Unmarshal(buff, &intermediate); err != nil {
		return err
	}
	for queryName, status := range intermediate.Statuses {
		rs.Statuses[queryName] = status
		// Sometimes we have a status but don't have a corresponding
		// result.
		queryResult, ok := intermediate.Queries[queryName]
		if !ok {
			rs.Queries[queryName] = emptyRow
			continue
		}
		// Deal with structurally inconsistent results, sometimes a query
		// without any results is just a name with an empty string.
		switch val := queryResult.(type) {
		case string:
			rs.Queries[queryName] = emptyRow
		case []interface{}:
			results, err := convertRows(val)
			if err != nil {
				return err
			}
			rs.Queries[queryName] = results
		default:
			return fmt.Errorf("results for %q unknown type", queryName)
		}
	}
	// Stats and messages don't require any format changes
	rs.Stats = intermediate.Stats
	rs.Messages = intermediate.Messages
	return nil
}

func (rs *ResultsStruct) toResults() ([]Result, error) {
	var results []Result
	for queryName, rows := range rs.Queries {
		result := Result{
			QueryName:  queryName,
			Rows:       rows,
			Status:     int(rs.Statuses[queryName]),
			QueryStats: nil,
		}
		if stats, ok := rs.Stats[queryName]; ok {
			result.QueryStats = &stats
		}
		if msg, ok := rs.Messages[queryName]; ok {
			result.Message = msg
		}
		results = append(results, result)
	}
	return results, nil
}

func convertRows(rows []interface{}) ([]map[string]string, error) {
	var results []map[string]string
	for _, intf := range rows {
		row, ok := intf.(map[string]interface{})
		if !ok {
			return nil, errors.New("invalid row type for query")
		}
		result := make(map[string]string)
		for col, val := range row {
			sval, ok := val.(string)
			if !ok {
				return nil, fmt.Errorf("invalid type for col %q", col)
			}
			result[col] = sval
		}
		results = append(results, result)
	}
	return results, nil
}

func (t *Plugin) Call(ctx context.Context, request osquery.ExtensionPluginRequest) osquery.ExtensionResponse {
	ctx, span := traces.StartSpan(ctx, "Distributed.Call", "action", request[requestActionKey])
	defer span.End()

	switch request[requestActionKey] {
	case getQueriesAction:
		queries, err := t.getQueries(ctx)
		if err != nil {
			return osquery.ExtensionResponse{
				Status: &osquery.ExtensionStatus{
					Code:    1,
					Message: "error getting queries: " + err.Error(),
				},
			}
		}

		queryJSON, err := json.Marshal(queries)
		if err != nil {
			return osquery.ExtensionResponse{
				Status: &osquery.ExtensionStatus{
					Code:    1,
					Message: "error marshalling queries: " + err.Error(),
				},
			}
		}

		return osquery.ExtensionResponse{
			Status:   &osquery.ExtensionStatus{Code: 0, Message: "OK"},
			Response: osquery.ExtensionPluginResponse{map[string]string{"results": string(queryJSON)}},
		}

	case writeResultsAction:
		var rs ResultsStruct
		if err := json.Unmarshal([]byte(request[requestResultKey]), &rs); err != nil {
			return osquery.ExtensionResponse{
				Status: &osquery.ExtensionStatus{
					Code:    1,
					Message: "error unmarshalling results: " + err.Error(),
				},
			}
		}
		results, err := rs.toResults()
		if err != nil {
			return osquery.ExtensionResponse{
				Status: &osquery.ExtensionStatus{
					Code:    1,
					Message: "error writing results: " + err.Error(),
				},
			}
		}
		// invoke callback
		err = t.writeResults(ctx, results)
		if err != nil {
			return osquery.ExtensionResponse{
				Status: &osquery.ExtensionStatus{
					Code:    1,
					Message: "error writing results: " + err.Error(),
				},
			}
		}

		return osquery.ExtensionResponse{
			Status:   &osquery.ExtensionStatus{Code: 0, Message: "OK"},
			Response: osquery.ExtensionPluginResponse{},
		}

	default:
		return osquery.ExtensionResponse{
			Status: &osquery.ExtensionStatus{
				Code:    1,
				Message: "unknown action: " + request["action"],
			},
		}
	}

}

func (t *Plugin) Shutdown() {}


================================================
FILE: plugin/distributed/distributed_test.go
================================================
package distributed

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"sort"
	"testing"

	"github.com/osquery/osquery-go/gen/osquery"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

var StatusOK = osquery.ExtensionStatus{Code: 0, Message: "OK"}

func TestDistributedPlugin(t *testing.T) {
	var getCalled, writeCalled bool
	var results []Result
	plugin := NewPlugin(
		"mock",
		func(context.Context) (*GetQueriesResult, error) {
			getCalled = true
			return &GetQueriesResult{
				Queries: map[string]string{
					"query1": "select iso_8601 from time",
					"query2": "select version from osquery_info",
					"query3": "select foo from bar",
				},
			}, nil
		},
		func(ctx context.Context, res []Result) error {
			writeCalled = true
			results = res
			return nil
		},
	)

	// Basic methods
	assert.Equal(t, "distributed", plugin.RegistryName())
	assert.Equal(t, "mock", plugin.Name())
	assert.Equal(t, StatusOK, plugin.Ping())
	assert.Equal(t, osquery.ExtensionPluginResponse{}, plugin.Routes())

	// Call getQueries
	resp := plugin.Call(context.Background(), osquery.ExtensionPluginRequest{"action": "getQueries"})
	assert.True(t, getCalled)
	assert.False(t, writeCalled)
	assert.Equal(t, &StatusOK, resp.Status)
	if assert.Len(t, resp.Response, 1) {
		assert.JSONEq(t, `{"queries": {"query1": "select iso_8601 from time", "query2": "select version from osquery_info", "query3": "select foo from bar"}}`,
			resp.Response[0]["resul