merge retry mechanism change from gorealis v1 to gorealis v2 (#21)

- pull capacity report via /offers endpoint.
- calculate how many tasks (with resource and constraints) can be fit in the cluster.
examples of using the above 2 features are in aurora-scheduler/australis#33

.auroraversion

@@ -1 +1 @@
-0.21.0
+0.26.0

.github/workflows/main.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+
+    runs-on: ubuntu-20.04
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Setup Go for use with actions
+      uses: actions/setup-go@v2
+      with:
+        go-version: 1.17
+    - name: Install goimports
+      run: go get golang.org/x/tools/cmd/goimports
+    - name: Set env with list of directories in repo containin go code
+      run: echo GO_USR_DIRS=$(go list -f {{.Dir}} ./... | grep -E -v "/gen-go/|/vendor/") >> $GITHUB_ENV
+    - name: Run goimports check
+      run: test -z "`for d in $GO_USR_DIRS; do goimports -d $d/*.go | tee /dev/stderr; done`"
+    - name: Create aurora/mesos docker cluster
+      run: docker-compose up -d
+    - name: Run tests
+      run: go test -timeout 35m -race -coverprofile=coverage.txt -covermode=atomic -v github.com/aurora-scheduler/gorealis/v2
+        

.gitignore

@@ -41,6 +41,3 @@ _testmain.go
 # Example client build
 examples/client
 examples/jsonClient
-
-# Use checksum database
-go.sum

Gopkg.lock

@@ -1,60 +0,0 @@
-# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
-
-
-[[projects]]
-  branch = "0.12.0"
-  digest = "1:89696c38cec777120b8b1bb5e2d363d655cf2e1e7d8c851919aaa0fd576d9b86"
-  name = "github.com/apache/thrift"
-  packages = ["lib/go/thrift"]
-  pruneopts = ""
-  revision = "384647d290e2e4a55a14b1b7ef1b7e66293a2c33"
-
-[[projects]]
-  digest = "1:0deddd908b6b4b768cfc272c16ee61e7088a60f7fe2f06c547bd3d8e1f8b8e77"
-  name = "github.com/davecgh/go-spew"
-  packages = ["spew"]
-  pruneopts = ""
-  revision = "8991bc29aa16c548c550c7ff78260e27b9ab7c73"
-  version = "v1.1.1"
-
-[[projects]]
-  digest = "1:df48fb76fb2a40edea0c9b3d960bc95e326660d82ff1114e1f88001f7a236b40"
-  name = "github.com/pkg/errors"
-  packages = ["."]
-  pruneopts = ""
-  revision = "e881fd58d78e04cf6d0de1217f8707c8cc2249bc"
-
-[[projects]]
-  digest = "1:256484dbbcd271f9ecebc6795b2df8cad4c458dd0f5fd82a8c2fa0c29f233411"
-  name = "github.com/pmezard/go-difflib"
-  packages = ["difflib"]
-  pruneopts = ""
-  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
-  version = "v1.0.0"
-
-[[projects]]
-  digest = "1:78bea5e26e82826dacc5fd64a1013a6711b7075ec8072819b89e6ad76cb8196d"
-  name = "github.com/samuel/go-zookeeper"
-  packages = ["zk"]
-  pruneopts = ""
-  revision = "471cd4e61d7a78ece1791fa5faa0345dc8c7d5a5"
-
-[[projects]]
-  digest = "1:c587772fb8ad29ad4db67575dad25ba17a51f072ff18a22b4f0257a4d9c24f75"
-  name = "github.com/stretchr/testify"
-  packages = ["assert"]
-  pruneopts = ""
-  revision = "f35b8ab0b5a2cef36673838d662e249dd9c94686"
-  version = "v1.2.2"
-
-[solve-meta]
-  analyzer-name = "dep"
-  analyzer-version = 1
-  input-imports = [
-    "github.com/apache/thrift/lib/go/thrift",
-    "github.com/pkg/errors",
-    "github.com/samuel/go-zookeeper/zk",
-    "github.com/stretchr/testify/assert",
-  ]
-  solver-name = "gps-cdcl"
-  solver-version = 1

Gopkg.toml

@@ -1,16 +0,0 @@
-[[constraint]]
-    name = "github.com/apache/thrift"
-    branch = "0.12.0"
-
-[[constraint]]
-    name = "github.com/pkg/errors"
-    revision = "e881fd58d78e04cf6d0de1217f8707c8cc2249bc"
-
-[[constraint]]
-    name = "github.com/samuel/go-zookeeper"
-    revision = "471cd4e61d7a78ece1791fa5faa0345dc8c7d5a5"
-
-[[constraint]]
-    name = "github.com/stretchr/testify"
-    version = "1.2.0"
-

auroraAPI.thrift

@@ -716,9 +716,40 @@ struct JobUpdateKey {
   2: string id
 }
 
+/** Limits the amount of active changes being made to instances to groupSize. */
+struct QueueJobUpdateStrategy {
+  1: i32 groupSize
+}
+
+/** Similar to Queue strategy but will not start a new group until all instances in an active
+ * group have finished updating.
+ */
+struct BatchJobUpdateStrategy {
+  1: i32 groupSize
+  /* Update will pause automatically after each batch completes */
+  2: bool autopauseAfterBatch
+}
+
+/** Same as Batch strategy but each time an active group completes, the size of the next active
+ * group may change.
+ */
+struct VariableBatchJobUpdateStrategy {
+  1: list<i32> groupSizes
+  /* Update will pause automatically after each batch completes */
+  2: bool autopauseAfterBatch
+}
+
+union JobUpdateStrategy {
+ 1: QueueJobUpdateStrategy queueStrategy
+ 2: BatchJobUpdateStrategy batchStrategy
+ 3: VariableBatchJobUpdateStrategy varBatchStrategy
+}
+
 /** Job update thresholds and limits. */
 struct JobUpdateSettings {
-  /** Max number of instances being updated at any given moment. */
+  /** Deprecated, please set value inside of desired update strategy instead.
+   * Max number of instances being updated at any given moment.
+   */
   1: i32 updateGroupSize
 
   /** Max number of instance failures to tolerate before marking instance as FAILED. */
@@ -736,7 +767,7 @@ struct JobUpdateSettings {
   /** Instance IDs to act on. All instances will be affected if this is not set. */
   7: set<Range> updateOnlyTheseInstances
 
-  /**
+  /** Deprecated, please set updateStrategy to the Batch strategy instead.
    * If true, use updateGroupSize as strict batching boundaries, and avoid proceeding to another
    * batch until the preceding batch finishes updating.
    */
@@ -755,6 +786,9 @@ struct JobUpdateSettings {
    * differs between the old and new task configurations, updates will use the newest configuration.
    */
   10: optional bool slaAware
+
+  /** Update strategy to be used for the update. See JobUpdateStrategy for choices. */
+  11: optional JobUpdateStrategy updateStrategy
 }
 
 /** Event marking a state transition in job update lifecycle. */

clusters.go

@@ -28,6 +28,7 @@ type Cluster struct {
 	ZK            string `json:"zk"`
 	ZKPort        int    `json:"zk_port"`
 	SchedZKPath   string `json:"scheduler_zk_path"`
+	MesosZKPath   string `json:"mesos_zk_path"`
 	SchedURI      string `json:"scheduler_uri"`
 	ProxyURL      string `json:"proxy_url"`
 	AuthMechanism string `json:"auth_mechanism"`
@@ -61,6 +62,7 @@ func GetDefaultClusterFromZKUrl(zkURL string) *Cluster {
 		AuthMechanism: "UNAUTHENTICATED",
 		ZK:            zkURL,
 		SchedZKPath:   "/aurora/scheduler",
+		MesosZKPath:   "/mesos",
 		AgentRunDir:   "latest",
 		AgentRoot:     "/var/lib/mesos",
 	}

clusters_test.go

@@ -32,6 +32,7 @@ func TestLoadClusters(t *testing.T) {
 	assert.Equal(t, clusters["devcluster"].Name, "devcluster")
 	assert.Equal(t, clusters["devcluster"].ZK, "192.168.33.7")
 	assert.Equal(t, clusters["devcluster"].SchedZKPath, "/aurora/scheduler")
+	assert.Equal(t, clusters["devcluster"].MesosZKPath, "/mesos")
 	assert.Equal(t, clusters["devcluster"].AuthMechanism, "UNAUTHENTICATED")
 	assert.Equal(t, clusters["devcluster"].AgentRunDir, "latest")
 	assert.Equal(t, clusters["devcluster"].AgentRoot, "/var/lib/mesos")

docker-compose.yml

@@ -14,7 +14,7 @@ services:
         ipv4_address: 192.168.33.2
 
   master:
-    image: rdelvalle/mesos-master:1.5.1
+    image: quay.io/aurorascheduler/mesos-master:1.9.0
     restart: on-failure
     ports:
     - "5050:5050"
@@ -32,7 +32,7 @@ services:
     - zk
 
   agent-one:
-    image: rdelvalle/mesos-agent:1.5.1
+    image: quay.io/aurorascheduler/mesos-agent:1.9.0
     pid: host
     restart: on-failure
     ports:
@@ -41,10 +41,11 @@ services:
       MESOS_MASTER: zk://192.168.33.2:2181/mesos
       MESOS_CONTAINERIZERS: docker,mesos
       MESOS_PORT: 5051
-      MESOS_HOSTNAME: localhost
+      MESOS_HOSTNAME: agent-one
       MESOS_RESOURCES: ports(*):[11000-11999]
       MESOS_SYSTEMD_ENABLE_SUPPORT: 'false'
       MESOS_WORK_DIR: /tmp/mesos
+      MESOS_ATTRIBUTES: 'host:agent-one;rack:1;zone:west'
     networks:
       aurora_cluster:
         ipv4_address: 192.168.33.4
@@ -55,8 +56,58 @@ services:
     depends_on:
     - zk
 
+  agent-two:
+    image: quay.io/aurorascheduler/mesos-agent:1.9.0
+    pid: host
+    restart: on-failure
+    ports:
+    - "5052:5051"
+    environment:
+      MESOS_MASTER: zk://192.168.33.2:2181/mesos
+      MESOS_CONTAINERIZERS: docker,mesos
+      MESOS_PORT: 5051
+      MESOS_HOSTNAME: agent-two
+      MESOS_RESOURCES: ports(*):[11000-11999]
+      MESOS_SYSTEMD_ENABLE_SUPPORT: 'false'
+      MESOS_WORK_DIR: /tmp/mesos
+      MESOS_ATTRIBUTES: 'host:agent-two;rack:2;zone:west'
+    networks:
+      aurora_cluster:
+        ipv4_address: 192.168.33.5
+
+    volumes:
+    - /sys/fs/cgroup:/sys/fs/cgroup
+    - /var/run/docker.sock:/var/run/docker.sock
+    depends_on:
+    - zk
+
+  agent-three:
+    image: quay.io/aurorascheduler/mesos-agent:1.9.0
+    pid: host
+    restart: on-failure
+    ports:
+    - "5053:5051"
+    environment:
+      MESOS_MASTER: zk://192.168.33.2:2181/mesos
+      MESOS_CONTAINERIZERS: docker,mesos
+      MESOS_PORT: 5051
+      MESOS_HOSTNAME: agent-three
+      MESOS_RESOURCES: ports(*):[11000-11999]
+      MESOS_SYSTEMD_ENABLE_SUPPORT: 'false'
+      MESOS_WORK_DIR: /tmp/mesos
+      MESOS_ATTRIBUTES: 'host:agent-three;rack:2;zone:west;dedicated:vagrant/bar'
+    networks:
+      aurora_cluster:
+        ipv4_address: 192.168.33.6
+
+    volumes:
+    - /sys/fs/cgroup:/sys/fs/cgroup
+    - /var/run/docker.sock:/var/run/docker.sock
+    depends_on:
+    - zk
+
   aurora-one:
-    image: rdelvalle/aurora:0.21.0
+    image: quay.io/aurorascheduler/scheduler:0.25.0
     pid: host
     ports:
     - "8081:8081"
@@ -69,6 +120,8 @@ services:
         -http_authentication_mechanism=BASIC
         -shiro_realm_modules=INI_AUTHNZ
         -shiro_ini_path=/etc/aurora/security.ini
+        -min_required_instances_for_sla_check=1
+        -thermos_executor_cpu=0.09
     volumes:
       - ./.aurora-config:/etc/aurora
     networks:

docs/developing.md

@@ -19,25 +19,18 @@ This also allows us to delete and recreate our development cluster very quickly.
 To install docker-compose please follow the instructions for your platform
 [here](https://docs.docker.com/compose/install/).
 
-
 ### Getting the source code
 
-As of go 1.10.x, GOPATH is still relevant. This may change in the future but
-for the sake of making development less error prone, it is suggested that the following
-directories be created:
+`$ git clone https://github.com/aurora-scheduler/gorealis`
 
-`$ mkdir -p $GOPATH/src/github.com/paypal`
+Inside of the newly cloned repo you may download dependencies to the local cache using go mod
 
-And then clone the master branch into the newly created folder:
-
-`$ cd $GOPATH/src/github.com/paypal; git clone git@github.com:paypal/gorealis.git`
-
-Since we check in our vendor folder, gorealis no further set up is needed.
+`$ go mod download`
 
 ### Bringing up the cluster
 
-To develop gorealis, you will need a fully functioning Mesos cluster along with
-Apache Aurora.
+To develop gorealis, you will need a fully functioning Mesos cluster along with 
+the Aurora Scheduler.
 
 In order to bring up our docker-compose set up execute the following command from the root
 of the git repository:
@@ -62,14 +55,14 @@ environment but not when running under MacOS. To run code involving the ZK leade
 For example, running the tests in a container can be done through the following command from
 the root of the git repository:
 
-`$ docker run -t -v $(pwd):/go/src/github.com/paypal/gorealis --network gorealis_aurora_cluster golang:1.10.3-alpine  go test github.com/paypal/gorealis`
+`$ docker run -t -v $(pwd):/go/src/github.com/aurora-scheduler/gorealis --network gorealis_aurora_cluster golang:1.14.3-alpine  go test github.com/paypal/gorealis`
 
 Or
 
 `$ ./runTestsMac.sh`
 
 Alternatively, if an interactive shell is necessary, the following command may be used:
-`$ docker run -it -v $(pwd):/go/src/github.com/paypal/gorealis --network gorealis_aurora_cluster golang:1.10.3-alpine /bin/sh`
+`$ docker run -it -v $(pwd):/go/src/github.com/paypal/gorealis --network gorealis_aurora_cluster golang:1.14.3-alpine /bin/sh`
 
 ### Cleaning up the cluster
 
@@ -85,6 +78,3 @@ Once development is done, the environment may be torn down by executing (from th
 git directory):
 
 `$ docker-compose down`
-
-
-

docs/getting-started.md

@@ -247,6 +247,9 @@ job = realis.NewJob().
     RAM(64).
     Disk(100).
     IsService(false).
+    Production(false).
+    Tier("preemptible").
+		Priority(0).
     InstanceCount(1).
     AddPorts(1).
     AddLabel("fileName", "sample-app/docker-compose.yml").
@@ -291,6 +294,9 @@ job = realis.NewJob().
     RAM(64).
     Disk(100).
     IsService(true).
+    Production(false).
+		Tier("preemptible").
+		Priority(0).
     InstanceCount(1).
     AddPorts(1)
 ```

docs/leveraging-the-library.md

@@ -25,6 +25,9 @@ job = realis.NewJob().
     RAM(64).
     Disk(100).
     IsService(false).
+    Production(false).
+    Tier("preemptible").
+    Priority(0).
     InstanceCount(1).
     AddPorts(1).
     AddLabel("fileName", "sample-app/docker-compose.yml").

docs/using-the-sample-client.md

@@ -22,28 +22,25 @@ Usage of ./client:
 ```
 
 ## Sample commands:
-These commands are set to run on a vagrant box. To be able to run the docker compose
-executor examples, the vagrant box must be configured properly to use the docker compose executor.
 
 ### Thermos
 
 #### Creating a Thermos job
 ```
-$ cd $GOPATH/src/github.com/paypal/gorealis/examples
-$ go run client.go -executor=thermos -url=http://192.168.33.7:8081 -cmd=create
+$ go run examples/client.go -url=http://localhost:8081 -executor=thermos -cmd=create
 ```
 #### Kill a Thermos job
 ```
-$ go run $GOPATH/src/github.com/paypal/gorealis/examples/client.go -executor=thermos -url=http://192.168.33.7:8081 -cmd=kill
+$ go run examples/client.go -url=http://localhost:8081 -executor=thermos -cmd=kill
 ```
 
 ### Docker Compose executor (custom executor)
 
 #### Creating Docker Compose executor job
 ```
-$ go run $GOPATH/src/github.com/paypal/gorealis/examples/client.go -executor=compose -url=http://192.168.33.7:8081 -cmd=create
+$ go run examples/client.go -url=http://192.168.33.7:8081 -executor=compose -cmd=create
 ```
 #### Kill a Docker Compose executor job
 ```
-$ go run $GOPATH/src/github.com/paypal/gorealis/examples/client.go -executor=compose -url=http://192.168.33.7:8081 -cmd=kill
+$ go run examples/client.go -url=http://192.168.33.7:8081 -executor=compose -cmd=kill
 ```

examples/client.go

@@ -124,6 +124,9 @@ func main() {
 			RAM(64).
 			Disk(100).
 			IsService(true).
+			Production(false).
+			Tier("preemptible").
+			Priority(0).
 			InstanceCount(1).
 			AddPorts(1).
 			ThermosExecutor(thermosExec)
@@ -138,6 +141,9 @@ func main() {
 			RAM(512).
 			Disk(100).
 			IsService(true).
+			Production(false).
+			Tier("preemptible").
+			Priority(0).
 			InstanceCount(1).
 			AddPorts(4).
 			AddLabel("fileName", "sample-app/docker-compose.yml").
@@ -151,6 +157,9 @@ func main() {
 			RAM(64).
 			Disk(100).
 			IsService(true).
+			Production(false).
+			Tier("preemptible").
+			Priority(0).
 			InstanceCount(1).
 			AddPorts(1)
 	default:

examples/clusters.json

@@ -2,6 +2,7 @@
   "name": "devcluster",
   "zk": "192.168.33.7",
   "scheduler_zk_path": "/aurora/scheduler",
+  "mesos_zk_path": "/mesos",
   "auth_mechanism": "UNAUTHENTICATED",
   "slave_run_directory": "latest",
   "slave_root": "/var/lib/mesos"

examples/jsonClient.go

@@ -177,6 +177,8 @@ func main() {
 			RAM(job.RAM).
 			Disk(job.Disk).
 			IsService(job.Service).
+			Tier("preemptible").
+			Priority(0).
 			InstanceCount(job.Instances).
 			AddPorts(job.Ports)
 

gen-go/apache/aurora/GoUnusedProtection__.go

@@ -1,5 +1,4 @@
-// Autogenerated by Thrift Compiler (0.12.0)
-// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+// Code generated by Thrift Compiler (0.14.0). DO NOT EDIT.
 
 package aurora
 

gen-go/apache/aurora/auroraAPI-consts.go

@@ -1,13 +1,12 @@
-// Autogenerated by Thrift Compiler (0.12.0)
-// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+// Code generated by Thrift Compiler (0.14.0). DO NOT EDIT.
 
 package aurora
 
-import (
+import(
 	"bytes"
 	"context"
-	"reflect"
 	"fmt"
+	"time"
 	"github.com/apache/thrift/lib/go/thrift"
 )
 
@@ -15,7 +14,7 @@ import (
 var _ = thrift.ZERO
 var _ = fmt.Printf
 var _ = context.Background
-var _ = reflect.DeepEqual
+var _ = time.Now
 var _ = bytes.Equal
 
 const AURORA_EXECUTOR_NAME = "AuroraExecutor"

gen-go/apache/aurora/aurora_scheduler_manager-remote/aurora_scheduler_manager-remote.go

@@ -1,22 +1,22 @@
-// Autogenerated by Thrift Compiler (0.12.0)
-// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+// Code generated by Thrift Compiler (0.14.0). DO NOT EDIT.
 
 package main
 
 import (
-        "context"
-        "flag"
-        "fmt"
-        "math"
-        "net"
-        "net/url"
-        "os"
-        "strconv"
-        "strings"
-        "github.com/apache/thrift/lib/go/thrift"
-        "apache/aurora"
+	"context"
+	"flag"
+	"fmt"
+	"math"
+	"net"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"github.com/apache/thrift/lib/go/thrift"
+	"apache/aurora"
 )
 
+var _ = aurora.GoUnusedProtection__
 
 func Usage() {
   fmt.Fprintln(os.Stderr, "Usage of ", os.Args[0], " [-h host:port] [-u url] [-f[ramed]] function [arg1 [arg2...]]:")
@@ -175,19 +175,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "CreateJob requires 1 args")
       flag.Usage()
     }
-    arg162 := flag.Arg(1)
-    mbTrans163 := thrift.NewTMemoryBufferLen(len(arg162))
-    defer mbTrans163.Close()
-    _, err164 := mbTrans163.WriteString(arg162)
-    if err164 != nil {
+    arg213 := flag.Arg(1)
+    mbTrans214 := thrift.NewTMemoryBufferLen(len(arg213))
+    defer mbTrans214.Close()
+    _, err215 := mbTrans214.WriteString(arg213)
+    if err215 != nil {
       Usage()
       return
     }
-    factory165 := thrift.NewTJSONProtocolFactory()
-    jsProt166 := factory165.GetProtocol(mbTrans163)
+    factory216 := thrift.NewTJSONProtocolFactory()
+    jsProt217 := factory216.GetProtocol(mbTrans214)
     argvalue0 := aurora.NewJobConfiguration()
-    err167 := argvalue0.Read(jsProt166)
-    if err167 != nil {
+    err218 := argvalue0.Read(context.Background(), jsProt217)
+    if err218 != nil {
       Usage()
       return
     }
@@ -200,19 +200,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "ScheduleCronJob requires 1 args")
       flag.Usage()
     }
-    arg168 := flag.Arg(1)
-    mbTrans169 := thrift.NewTMemoryBufferLen(len(arg168))
-    defer mbTrans169.Close()
-    _, err170 := mbTrans169.WriteString(arg168)
-    if err170 != nil {
+    arg219 := flag.Arg(1)
+    mbTrans220 := thrift.NewTMemoryBufferLen(len(arg219))
+    defer mbTrans220.Close()
+    _, err221 := mbTrans220.WriteString(arg219)
+    if err221 != nil {
       Usage()
       return
     }
-    factory171 := thrift.NewTJSONProtocolFactory()
-    jsProt172 := factory171.GetProtocol(mbTrans169)
+    factory222 := thrift.NewTJSONProtocolFactory()
+    jsProt223 := factory222.GetProtocol(mbTrans220)
     argvalue0 := aurora.NewJobConfiguration()
-    err173 := argvalue0.Read(jsProt172)
-    if err173 != nil {
+    err224 := argvalue0.Read(context.Background(), jsProt223)
+    if err224 != nil {
       Usage()
       return
     }
@@ -225,19 +225,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "DescheduleCronJob requires 1 args")
       flag.Usage()
     }
-    arg174 := flag.Arg(1)
-    mbTrans175 := thrift.NewTMemoryBufferLen(len(arg174))
-    defer mbTrans175.Close()
-    _, err176 := mbTrans175.WriteString(arg174)
-    if err176 != nil {
+    arg225 := flag.Arg(1)
+    mbTrans226 := thrift.NewTMemoryBufferLen(len(arg225))
+    defer mbTrans226.Close()
+    _, err227 := mbTrans226.WriteString(arg225)
+    if err227 != nil {
       Usage()
       return
     }
-    factory177 := thrift.NewTJSONProtocolFactory()
-    jsProt178 := factory177.GetProtocol(mbTrans175)
+    factory228 := thrift.NewTJSONProtocolFactory()
+    jsProt229 := factory228.GetProtocol(mbTrans226)
     argvalue0 := aurora.NewJobKey()
-    err179 := argvalue0.Read(jsProt178)
-    if err179 != nil {
+    err230 := argvalue0.Read(context.Background(), jsProt229)
+    if err230 != nil {
       Usage()
       return
     }
@@ -250,19 +250,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "StartCronJob requires 1 args")
       flag.Usage()
     }
-    arg180 := flag.Arg(1)
-    mbTrans181 := thrift.NewTMemoryBufferLen(len(arg180))
-    defer mbTrans181.Close()
-    _, err182 := mbTrans181.WriteString(arg180)
-    if err182 != nil {
+    arg231 := flag.Arg(1)
+    mbTrans232 := thrift.NewTMemoryBufferLen(len(arg231))
+    defer mbTrans232.Close()
+    _, err233 := mbTrans232.WriteString(arg231)
+    if err233 != nil {
       Usage()
       return
     }
-    factory183 := thrift.NewTJSONProtocolFactory()
-    jsProt184 := factory183.GetProtocol(mbTrans181)
+    factory234 := thrift.NewTJSONProtocolFactory()
+    jsProt235 := factory234.GetProtocol(mbTrans232)
     argvalue0 := aurora.NewJobKey()
-    err185 := argvalue0.Read(jsProt184)
-    if err185 != nil {
+    err236 := argvalue0.Read(context.Background(), jsProt235)
+    if err236 != nil {
       Usage()
       return
     }
@@ -275,36 +275,36 @@ func main() {
       fmt.Fprintln(os.Stderr, "RestartShards requires 2 args")
       flag.Usage()
     }
-    arg186 := flag.Arg(1)
-    mbTrans187 := thrift.NewTMemoryBufferLen(len(arg186))
-    defer mbTrans187.Close()
-    _, err188 := mbTrans187.WriteString(arg186)
-    if err188 != nil {
+    arg237 := flag.Arg(1)
+    mbTrans238 := thrift.NewTMemoryBufferLen(len(arg237))
+    defer mbTrans238.Close()
+    _, err239 := mbTrans238.WriteString(arg237)
+    if err239 != nil {
       Usage()
       return
     }
-    factory189 := thrift.NewTJSONProtocolFactory()
-    jsProt190 := factory189.GetProtocol(mbTrans187)
+    factory240 := thrift.NewTJSONProtocolFactory()
+    jsProt241 := factory240.GetProtocol(mbTrans238)
     argvalue0 := aurora.NewJobKey()
-    err191 := argvalue0.Read(jsProt190)
-    if err191 != nil {
+    err242 := argvalue0.Read(context.Background(), jsProt241)
+    if err242 != nil {
       Usage()
       return
     }
     value0 := argvalue0
-    arg192 := flag.Arg(2)
-    mbTrans193 := thrift.NewTMemoryBufferLen(len(arg192))
-    defer mbTrans193.Close()
-    _, err194 := mbTrans193.WriteString(arg192)
-    if err194 != nil { 
+    arg243 := flag.Arg(2)
+    mbTrans244 := thrift.NewTMemoryBufferLen(len(arg243))
+    defer mbTrans244.Close()
+    _, err245 := mbTrans244.WriteString(arg243)
+    if err245 != nil { 
       Usage()
       return
     }
-    factory195 := thrift.NewTJSONProtocolFactory()
-    jsProt196 := factory195.GetProtocol(mbTrans193)
+    factory246 := thrift.NewTJSONProtocolFactory()
+    jsProt247 := factory246.GetProtocol(mbTrans244)
     containerStruct1 := aurora.NewAuroraSchedulerManagerRestartShardsArgs()
-    err197 := containerStruct1.ReadField2(jsProt196)
-    if err197 != nil {
+    err248 := containerStruct1.ReadField2(context.Background(), jsProt247)
+    if err248 != nil {
       Usage()
       return
     }
@@ -318,36 +318,36 @@ func main() {
       fmt.Fprintln(os.Stderr, "KillTasks requires 3 args")
       flag.Usage()
     }
-    arg198 := flag.Arg(1)
-    mbTrans199 := thrift.NewTMemoryBufferLen(len(arg198))
-    defer mbTrans199.Close()
-    _, err200 := mbTrans199.WriteString(arg198)
-    if err200 != nil {
+    arg249 := flag.Arg(1)
+    mbTrans250 := thrift.NewTMemoryBufferLen(len(arg249))
+    defer mbTrans250.Close()
+    _, err251 := mbTrans250.WriteString(arg249)
+    if err251 != nil {
       Usage()
       return
     }
-    factory201 := thrift.NewTJSONProtocolFactory()
-    jsProt202 := factory201.GetProtocol(mbTrans199)
+    factory252 := thrift.NewTJSONProtocolFactory()
+    jsProt253 := factory252.GetProtocol(mbTrans250)
     argvalue0 := aurora.NewJobKey()
-    err203 := argvalue0.Read(jsProt202)
-    if err203 != nil {
+    err254 := argvalue0.Read(context.Background(), jsProt253)
+    if err254 != nil {
       Usage()
       return
     }
     value0 := argvalue0
-    arg204 := flag.Arg(2)
-    mbTrans205 := thrift.NewTMemoryBufferLen(len(arg204))
-    defer mbTrans205.Close()
-    _, err206 := mbTrans205.WriteString(arg204)
-    if err206 != nil { 
+    arg255 := flag.Arg(2)
+    mbTrans256 := thrift.NewTMemoryBufferLen(len(arg255))
+    defer mbTrans256.Close()
+    _, err257 := mbTrans256.WriteString(arg255)
+    if err257 != nil { 
       Usage()
       return
     }
-    factory207 := thrift.NewTJSONProtocolFactory()
-    jsProt208 := factory207.GetProtocol(mbTrans205)
+    factory258 := thrift.NewTJSONProtocolFactory()
+    jsProt259 := factory258.GetProtocol(mbTrans256)
     containerStruct1 := aurora.NewAuroraSchedulerManagerKillTasksArgs()
-    err209 := containerStruct1.ReadField2(jsProt208)
-    if err209 != nil {
+    err260 := containerStruct1.ReadField2(context.Background(), jsProt259)
+    if err260 != nil {
       Usage()
       return
     }
@@ -363,25 +363,25 @@ func main() {
       fmt.Fprintln(os.Stderr, "AddInstances requires 2 args")
       flag.Usage()
     }
-    arg211 := flag.Arg(1)
-    mbTrans212 := thrift.NewTMemoryBufferLen(len(arg211))
-    defer mbTrans212.Close()
-    _, err213 := mbTrans212.WriteString(arg211)
-    if err213 != nil {
+    arg262 := flag.Arg(1)
+    mbTrans263 := thrift.NewTMemoryBufferLen(len(arg262))
+    defer mbTrans263.Close()
+    _, err264 := mbTrans263.WriteString(arg262)
+    if err264 != nil {
       Usage()
       return
     }
-    factory214 := thrift.NewTJSONProtocolFactory()
-    jsProt215 := factory214.GetProtocol(mbTrans212)
+    factory265 := thrift.NewTJSONProtocolFactory()
+    jsProt266 := factory265.GetProtocol(mbTrans263)
     argvalue0 := aurora.NewInstanceKey()
-    err216 := argvalue0.Read(jsProt215)
-    if err216 != nil {
+    err267 := argvalue0.Read(context.Background(), jsProt266)
+    if err267 != nil {
       Usage()
       return
     }
     value0 := argvalue0
-    tmp1, err217 := (strconv.Atoi(flag.Arg(2)))
-    if err217 != nil {
+    tmp1, err268 := (strconv.Atoi(flag.Arg(2)))
+    if err268 != nil {
       Usage()
       return
     }
@@ -395,19 +395,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "ReplaceCronTemplate requires 1 args")
       flag.Usage()
     }
-    arg218 := flag.Arg(1)
-    mbTrans219 := thrift.NewTMemoryBufferLen(len(arg218))
-    defer mbTrans219.Close()
-    _, err220 := mbTrans219.WriteString(arg218)
-    if err220 != nil {
+    arg269 := flag.Arg(1)
+    mbTrans270 := thrift.NewTMemoryBufferLen(len(arg269))
+    defer mbTrans270.Close()
+    _, err271 := mbTrans270.WriteString(arg269)
+    if err271 != nil {
       Usage()
       return
     }
-    factory221 := thrift.NewTJSONProtocolFactory()
-    jsProt222 := factory221.GetProtocol(mbTrans219)
+    factory272 := thrift.NewTJSONProtocolFactory()
+    jsProt273 := factory272.GetProtocol(mbTrans270)
     argvalue0 := aurora.NewJobConfiguration()
-    err223 := argvalue0.Read(jsProt222)
-    if err223 != nil {
+    err274 := argvalue0.Read(context.Background(), jsProt273)
+    if err274 != nil {
       Usage()
       return
     }
@@ -420,19 +420,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "StartJobUpdate requires 2 args")
       flag.Usage()
     }
-    arg224 := flag.Arg(1)
-    mbTrans225 := thrift.NewTMemoryBufferLen(len(arg224))
-    defer mbTrans225.Close()
-    _, err226 := mbTrans225.WriteString(arg224)
-    if err226 != nil {
+    arg275 := flag.Arg(1)
+    mbTrans276 := thrift.NewTMemoryBufferLen(len(arg275))
+    defer mbTrans276.Close()
+    _, err277 := mbTrans276.WriteString(arg275)
+    if err277 != nil {
       Usage()
       return
     }
-    factory227 := thrift.NewTJSONProtocolFactory()
-    jsProt228 := factory227.GetProtocol(mbTrans225)
+    factory278 := thrift.NewTJSONProtocolFactory()
+    jsProt279 := factory278.GetProtocol(mbTrans276)
     argvalue0 := aurora.NewJobUpdateRequest()
-    err229 := argvalue0.Read(jsProt228)
-    if err229 != nil {
+    err280 := argvalue0.Read(context.Background(), jsProt279)
+    if err280 != nil {
       Usage()
       return
     }
@@ -447,19 +447,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "PauseJobUpdate requires 2 args")
       flag.Usage()
     }
-    arg231 := flag.Arg(1)
-    mbTrans232 := thrift.NewTMemoryBufferLen(len(arg231))
-    defer mbTrans232.Close()
-    _, err233 := mbTrans232.WriteString(arg231)
-    if err233 != nil {
+    arg282 := flag.Arg(1)
+    mbTrans283 := thrift.NewTMemoryBufferLen(len(arg282))
+    defer mbTrans283.Close()
+    _, err284 := mbTrans283.WriteString(arg282)
+    if err284 != nil {
       Usage()
       return
     }
-    factory234 := thrift.NewTJSONProtocolFactory()
-    jsProt235 := factory234.GetProtocol(mbTrans232)
+    factory285 := thrift.NewTJSONProtocolFactory()
+    jsProt286 := factory285.GetProtocol(mbTrans283)
     argvalue0 := aurora.NewJobUpdateKey()
-    err236 := argvalue0.Read(jsProt235)
-    if err236 != nil {
+    err287 := argvalue0.Read(context.Background(), jsProt286)
+    if err287 != nil {
       Usage()
       return
     }
@@ -474,19 +474,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "ResumeJobUpdate requires 2 args")
       flag.Usage()
     }
-    arg238 := flag.Arg(1)
-    mbTrans239 := thrift.NewTMemoryBufferLen(len(arg238))
-    defer mbTrans239.Close()
-    _, err240 := mbTrans239.WriteString(arg238)
-    if err240 != nil {
+    arg289 := flag.Arg(1)
+    mbTrans290 := thrift.NewTMemoryBufferLen(len(arg289))
+    defer mbTrans290.Close()
+    _, err291 := mbTrans290.WriteString(arg289)
+    if err291 != nil {
       Usage()
       return
     }
-    factory241 := thrift.NewTJSONProtocolFactory()
-    jsProt242 := factory241.GetProtocol(mbTrans239)
+    factory292 := thrift.NewTJSONProtocolFactory()
+    jsProt293 := factory292.GetProtocol(mbTrans290)
     argvalue0 := aurora.NewJobUpdateKey()
-    err243 := argvalue0.Read(jsProt242)
-    if err243 != nil {
+    err294 := argvalue0.Read(context.Background(), jsProt293)
+    if err294 != nil {
       Usage()
       return
     }
@@ -501,19 +501,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "AbortJobUpdate requires 2 args")
       flag.Usage()
     }
-    arg245 := flag.Arg(1)
-    mbTrans246 := thrift.NewTMemoryBufferLen(len(arg245))
-    defer mbTrans246.Close()
-    _, err247 := mbTrans246.WriteString(arg245)
-    if err247 != nil {
+    arg296 := flag.Arg(1)
+    mbTrans297 := thrift.NewTMemoryBufferLen(len(arg296))
+    defer mbTrans297.Close()
+    _, err298 := mbTrans297.WriteString(arg296)
+    if err298 != nil {
       Usage()
       return
     }
-    factory248 := thrift.NewTJSONProtocolFactory()
-    jsProt249 := factory248.GetProtocol(mbTrans246)
+    factory299 := thrift.NewTJSONProtocolFactory()
+    jsProt300 := factory299.GetProtocol(mbTrans297)
     argvalue0 := aurora.NewJobUpdateKey()
-    err250 := argvalue0.Read(jsProt249)
-    if err250 != nil {
+    err301 := argvalue0.Read(context.Background(), jsProt300)
+    if err301 != nil {
       Usage()
       return
     }
@@ -528,19 +528,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "RollbackJobUpdate requires 2 args")
       flag.Usage()
     }
-    arg252 := flag.Arg(1)
-    mbTrans253 := thrift.NewTMemoryBufferLen(len(arg252))
-    defer mbTrans253.Close()
-    _, err254 := mbTrans253.WriteString(arg252)
-    if err254 != nil {
+    arg303 := flag.Arg(1)
+    mbTrans304 := thrift.NewTMemoryBufferLen(len(arg303))
+    defer mbTrans304.Close()
+    _, err305 := mbTrans304.WriteString(arg303)
+    if err305 != nil {
       Usage()
       return
     }
-    factory255 := thrift.NewTJSONProtocolFactory()
-    jsProt256 := factory255.GetProtocol(mbTrans253)
+    factory306 := thrift.NewTJSONProtocolFactory()
+    jsProt307 := factory306.GetProtocol(mbTrans304)
     argvalue0 := aurora.NewJobUpdateKey()
-    err257 := argvalue0.Read(jsProt256)
-    if err257 != nil {
+    err308 := argvalue0.Read(context.Background(), jsProt307)
+    if err308 != nil {
       Usage()
       return
     }
@@ -555,19 +555,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "PulseJobUpdate requires 1 args")
       flag.Usage()
     }
-    arg259 := flag.Arg(1)
-    mbTrans260 := thrift.NewTMemoryBufferLen(len(arg259))
-    defer mbTrans260.Close()
-    _, err261 := mbTrans260.WriteString(arg259)
-    if err261 != nil {
+    arg310 := flag.Arg(1)
+    mbTrans311 := thrift.NewTMemoryBufferLen(len(arg310))
+    defer mbTrans311.Close()
+    _, err312 := mbTrans311.WriteString(arg310)
+    if err312 != nil {
       Usage()
       return
     }
-    factory262 := thrift.NewTJSONProtocolFactory()
-    jsProt263 := factory262.GetProtocol(mbTrans260)
+    factory313 := thrift.NewTJSONProtocolFactory()
+    jsProt314 := factory313.GetProtocol(mbTrans311)
     argvalue0 := aurora.NewJobUpdateKey()
-    err264 := argvalue0.Read(jsProt263)
-    if err264 != nil {
+    err315 := argvalue0.Read(context.Background(), jsProt314)
+    if err315 != nil {
       Usage()
       return
     }
@@ -598,19 +598,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
       flag.Usage()
     }
-    arg266 := flag.Arg(1)
-    mbTrans267 := thrift.NewTMemoryBufferLen(len(arg266))
-    defer mbTrans267.Close()
-    _, err268 := mbTrans267.WriteString(arg266)
-    if err268 != nil {
+    arg317 := flag.Arg(1)
+    mbTrans318 := thrift.NewTMemoryBufferLen(len(arg317))
+    defer mbTrans318.Close()
+    _, err319 := mbTrans318.WriteString(arg317)
+    if err319 != nil {
       Usage()
       return
     }
-    factory269 := thrift.NewTJSONProtocolFactory()
-    jsProt270 := factory269.GetProtocol(mbTrans267)
+    factory320 := thrift.NewTJSONProtocolFactory()
+    jsProt321 := factory320.GetProtocol(mbTrans318)
     argvalue0 := aurora.NewTaskQuery()
-    err271 := argvalue0.Read(jsProt270)
-    if err271 != nil {
+    err322 := argvalue0.Read(context.Background(), jsProt321)
+    if err322 != nil {
       Usage()
       return
     }
@@ -623,19 +623,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
       flag.Usage()
     }
-    arg272 := flag.Arg(1)
-    mbTrans273 := thrift.NewTMemoryBufferLen(len(arg272))
-    defer mbTrans273.Close()
-    _, err274 := mbTrans273.WriteString(arg272)
-    if err274 != nil {
+    arg323 := flag.Arg(1)
+    mbTrans324 := thrift.NewTMemoryBufferLen(len(arg323))
+    defer mbTrans324.Close()
+    _, err325 := mbTrans324.WriteString(arg323)
+    if err325 != nil {
       Usage()
       return
     }
-    factory275 := thrift.NewTJSONProtocolFactory()
-    jsProt276 := factory275.GetProtocol(mbTrans273)
+    factory326 := thrift.NewTJSONProtocolFactory()
+    jsProt327 := factory326.GetProtocol(mbTrans324)
     argvalue0 := aurora.NewTaskQuery()
-    err277 := argvalue0.Read(jsProt276)
-    if err277 != nil {
+    err328 := argvalue0.Read(context.Background(), jsProt327)
+    if err328 != nil {
       Usage()
       return
     }
@@ -648,19 +648,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
       flag.Usage()
     }
-    arg278 := flag.Arg(1)
-    mbTrans279 := thrift.NewTMemoryBufferLen(len(arg278))
-    defer mbTrans279.Close()
-    _, err280 := mbTrans279.WriteString(arg278)
-    if err280 != nil {
+    arg329 := flag.Arg(1)
+    mbTrans330 := thrift.NewTMemoryBufferLen(len(arg329))
+    defer mbTrans330.Close()
+    _, err331 := mbTrans330.WriteString(arg329)
+    if err331 != nil {
       Usage()
       return
     }
-    factory281 := thrift.NewTJSONProtocolFactory()
-    jsProt282 := factory281.GetProtocol(mbTrans279)
+    factory332 := thrift.NewTJSONProtocolFactory()
+    jsProt333 := factory332.GetProtocol(mbTrans330)
     argvalue0 := aurora.NewTaskQuery()
-    err283 := argvalue0.Read(jsProt282)
-    if err283 != nil {
+    err334 := argvalue0.Read(context.Background(), jsProt333)
+    if err334 != nil {
       Usage()
       return
     }
@@ -673,19 +673,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
       flag.Usage()
     }
-    arg284 := flag.Arg(1)
-    mbTrans285 := thrift.NewTMemoryBufferLen(len(arg284))
-    defer mbTrans285.Close()
-    _, err286 := mbTrans285.WriteString(arg284)
-    if err286 != nil {
+    arg335 := flag.Arg(1)
+    mbTrans336 := thrift.NewTMemoryBufferLen(len(arg335))
+    defer mbTrans336.Close()
+    _, err337 := mbTrans336.WriteString(arg335)
+    if err337 != nil {
       Usage()
       return
     }
-    factory287 := thrift.NewTJSONProtocolFactory()
-    jsProt288 := factory287.GetProtocol(mbTrans285)
+    factory338 := thrift.NewTJSONProtocolFactory()
+    jsProt339 := factory338.GetProtocol(mbTrans336)
     argvalue0 := aurora.NewJobKey()
-    err289 := argvalue0.Read(jsProt288)
-    if err289 != nil {
+    err340 := argvalue0.Read(context.Background(), jsProt339)
+    if err340 != nil {
       Usage()
       return
     }
@@ -718,19 +718,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
       flag.Usage()
     }
-    arg292 := flag.Arg(1)
-    mbTrans293 := thrift.NewTMemoryBufferLen(len(arg292))
-    defer mbTrans293.Close()
-    _, err294 := mbTrans293.WriteString(arg292)
-    if err294 != nil {
+    arg343 := flag.Arg(1)
+    mbTrans344 := thrift.NewTMemoryBufferLen(len(arg343))
+    defer mbTrans344.Close()
+    _, err345 := mbTrans344.WriteString(arg343)
+    if err345 != nil {
       Usage()
       return
     }
-    factory295 := thrift.NewTJSONProtocolFactory()
-    jsProt296 := factory295.GetProtocol(mbTrans293)
+    factory346 := thrift.NewTJSONProtocolFactory()
+    jsProt347 := factory346.GetProtocol(mbTrans344)
     argvalue0 := aurora.NewJobConfiguration()
-    err297 := argvalue0.Read(jsProt296)
-    if err297 != nil {
+    err348 := argvalue0.Read(context.Background(), jsProt347)
+    if err348 != nil {
       Usage()
       return
     }
@@ -743,19 +743,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
       flag.Usage()
     }
-    arg298 := flag.Arg(1)
-    mbTrans299 := thrift.NewTMemoryBufferLen(len(arg298))
-    defer mbTrans299.Close()
-    _, err300 := mbTrans299.WriteString(arg298)
-    if err300 != nil {
+    arg349 := flag.Arg(1)
+    mbTrans350 := thrift.NewTMemoryBufferLen(len(arg349))
+    defer mbTrans350.Close()
+    _, err351 := mbTrans350.WriteString(arg349)
+    if err351 != nil {
       Usage()
       return
     }
-    factory301 := thrift.NewTJSONProtocolFactory()
-    jsProt302 := factory301.GetProtocol(mbTrans299)
+    factory352 := thrift.NewTJSONProtocolFactory()
+    jsProt353 := factory352.GetProtocol(mbTrans350)
     argvalue0 := aurora.NewJobUpdateQuery()
-    err303 := argvalue0.Read(jsProt302)
-    if err303 != nil {
+    err354 := argvalue0.Read(context.Background(), jsProt353)
+    if err354 != nil {
       Usage()
       return
     }
@@ -768,19 +768,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
       flag.Usage()
     }
-    arg304 := flag.Arg(1)
-    mbTrans305 := thrift.NewTMemoryBufferLen(len(arg304))
-    defer mbTrans305.Close()
-    _, err306 := mbTrans305.WriteString(arg304)
-    if err306 != nil {
+    arg355 := flag.Arg(1)
+    mbTrans356 := thrift.NewTMemoryBufferLen(len(arg355))
+    defer mbTrans356.Close()
+    _, err357 := mbTrans356.WriteString(arg355)
+    if err357 != nil {
       Usage()
       return
     }
-    factory307 := thrift.NewTJSONProtocolFactory()
-    jsProt308 := factory307.GetProtocol(mbTrans305)
+    factory358 := thrift.NewTJSONProtocolFactory()
+    jsProt359 := factory358.GetProtocol(mbTrans356)
     argvalue0 := aurora.NewJobUpdateQuery()
-    err309 := argvalue0.Read(jsProt308)
-    if err309 != nil {
+    err360 := argvalue0.Read(context.Background(), jsProt359)
+    if err360 != nil {
       Usage()
       return
     }
@@ -793,19 +793,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
       flag.Usage()
     }
-    arg310 := flag.Arg(1)
-    mbTrans311 := thrift.NewTMemoryBufferLen(len(arg310))
-    defer mbTrans311.Close()
-    _, err312 := mbTrans311.WriteString(arg310)
-    if err312 != nil {
+    arg361 := flag.Arg(1)
+    mbTrans362 := thrift.NewTMemoryBufferLen(len(arg361))
+    defer mbTrans362.Close()
+    _, err363 := mbTrans362.WriteString(arg361)
+    if err363 != nil {
       Usage()
       return
     }
-    factory313 := thrift.NewTJSONProtocolFactory()
-    jsProt314 := factory313.GetProtocol(mbTrans311)
+    factory364 := thrift.NewTJSONProtocolFactory()
+    jsProt365 := factory364.GetProtocol(mbTrans362)
     argvalue0 := aurora.NewJobUpdateRequest()
-    err315 := argvalue0.Read(jsProt314)
-    if err315 != nil {
+    err366 := argvalue0.Read(context.Background(), jsProt365)
+    if err366 != nil {
       Usage()
       return
     }

gen-go/apache/aurora/read_only_scheduler-remote/read_only_scheduler-remote.go

@@ -1,22 +1,22 @@
-// Autogenerated by Thrift Compiler (0.12.0)
-// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+// Code generated by Thrift Compiler (0.14.0). DO NOT EDIT.
 
 package main
 
 import (
-        "context"
-        "flag"
-        "fmt"
-        "math"
-        "net"
-        "net/url"
-        "os"
-        "strconv"
-        "strings"
-        "github.com/apache/thrift/lib/go/thrift"
-        "apache/aurora"
+	"context"
+	"flag"
+	"fmt"
+	"math"
+	"net"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"github.com/apache/thrift/lib/go/thrift"
+	"apache/aurora"
 )
 
+var _ = aurora.GoUnusedProtection__
 
 func Usage() {
   fmt.Fprintln(os.Stderr, "Usage of ", os.Args[0], " [-h host:port] [-u url] [-f[ramed]] function [arg1 [arg2...]]:")
@@ -179,19 +179,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
       flag.Usage()
     }
-    arg81 := flag.Arg(1)
-    mbTrans82 := thrift.NewTMemoryBufferLen(len(arg81))
-    defer mbTrans82.Close()
-    _, err83 := mbTrans82.WriteString(arg81)
-    if err83 != nil {
+    arg132 := flag.Arg(1)
+    mbTrans133 := thrift.NewTMemoryBufferLen(len(arg132))
+    defer mbTrans133.Close()
+    _, err134 := mbTrans133.WriteString(arg132)
+    if err134 != nil {
       Usage()
       return
     }
-    factory84 := thrift.NewTJSONProtocolFactory()
-    jsProt85 := factory84.GetProtocol(mbTrans82)
+    factory135 := thrift.NewTJSONProtocolFactory()
+    jsProt136 := factory135.GetProtocol(mbTrans133)
     argvalue0 := aurora.NewTaskQuery()
-    err86 := argvalue0.Read(jsProt85)
-    if err86 != nil {
+    err137 := argvalue0.Read(context.Background(), jsProt136)
+    if err137 != nil {
       Usage()
       return
     }
@@ -204,19 +204,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
       flag.Usage()
     }
-    arg87 := flag.Arg(1)
-    mbTrans88 := thrift.NewTMemoryBufferLen(len(arg87))
-    defer mbTrans88.Close()
-    _, err89 := mbTrans88.WriteString(arg87)
-    if err89 != nil {
+    arg138 := flag.Arg(1)
+    mbTrans139 := thrift.NewTMemoryBufferLen(len(arg138))
+    defer mbTrans139.Close()
+    _, err140 := mbTrans139.WriteString(arg138)
+    if err140 != nil {
       Usage()
       return
     }
-    factory90 := thrift.NewTJSONProtocolFactory()
-    jsProt91 := factory90.GetProtocol(mbTrans88)
+    factory141 := thrift.NewTJSONProtocolFactory()
+    jsProt142 := factory141.GetProtocol(mbTrans139)
     argvalue0 := aurora.NewTaskQuery()
-    err92 := argvalue0.Read(jsProt91)
-    if err92 != nil {
+    err143 := argvalue0.Read(context.Background(), jsProt142)
+    if err143 != nil {
       Usage()
       return
     }
@@ -229,19 +229,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
       flag.Usage()
     }
-    arg93 := flag.Arg(1)
-    mbTrans94 := thrift.NewTMemoryBufferLen(len(arg93))
-    defer mbTrans94.Close()
-    _, err95 := mbTrans94.WriteString(arg93)
-    if err95 != nil {
+    arg144 := flag.Arg(1)
+    mbTrans145 := thrift.NewTMemoryBufferLen(len(arg144))
+    defer mbTrans145.Close()
+    _, err146 := mbTrans145.WriteString(arg144)
+    if err146 != nil {
       Usage()
       return
     }
-    factory96 := thrift.NewTJSONProtocolFactory()
-    jsProt97 := factory96.GetProtocol(mbTrans94)
+    factory147 := thrift.NewTJSONProtocolFactory()
+    jsProt148 := factory147.GetProtocol(mbTrans145)
     argvalue0 := aurora.NewTaskQuery()
-    err98 := argvalue0.Read(jsProt97)
-    if err98 != nil {
+    err149 := argvalue0.Read(context.Background(), jsProt148)
+    if err149 != nil {
       Usage()
       return
     }
@@ -254,19 +254,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
       flag.Usage()
     }
-    arg99 := flag.Arg(1)
-    mbTrans100 := thrift.NewTMemoryBufferLen(len(arg99))
-    defer mbTrans100.Close()
-    _, err101 := mbTrans100.WriteString(arg99)
-    if err101 != nil {
+    arg150 := flag.Arg(1)
+    mbTrans151 := thrift.NewTMemoryBufferLen(len(arg150))
+    defer mbTrans151.Close()
+    _, err152 := mbTrans151.WriteString(arg150)
+    if err152 != nil {
       Usage()
       return
     }
-    factory102 := thrift.NewTJSONProtocolFactory()
-    jsProt103 := factory102.GetProtocol(mbTrans100)
+    factory153 := thrift.NewTJSONProtocolFactory()
+    jsProt154 := factory153.GetProtocol(mbTrans151)
     argvalue0 := aurora.NewJobKey()
-    err104 := argvalue0.Read(jsProt103)
-    if err104 != nil {
+    err155 := argvalue0.Read(context.Background(), jsProt154)
+    if err155 != nil {
       Usage()
       return
     }
@@ -299,19 +299,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
       flag.Usage()
     }
-    arg107 := flag.Arg(1)
-    mbTrans108 := thrift.NewTMemoryBufferLen(len(arg107))
-    defer mbTrans108.Close()
-    _, err109 := mbTrans108.WriteString(arg107)
-    if err109 != nil {
+    arg158 := flag.Arg(1)
+    mbTrans159 := thrift.NewTMemoryBufferLen(len(arg158))
+    defer mbTrans159.Close()
+    _, err160 := mbTrans159.WriteString(arg158)
+    if err160 != nil {
       Usage()
       return
     }
-    factory110 := thrift.NewTJSONProtocolFactory()
-    jsProt111 := factory110.GetProtocol(mbTrans108)
+    factory161 := thrift.NewTJSONProtocolFactory()
+    jsProt162 := factory161.GetProtocol(mbTrans159)
     argvalue0 := aurora.NewJobConfiguration()
-    err112 := argvalue0.Read(jsProt111)
-    if err112 != nil {
+    err163 := argvalue0.Read(context.Background(), jsProt162)
+    if err163 != nil {
       Usage()
       return
     }
@@ -324,19 +324,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
       flag.Usage()
     }
-    arg113 := flag.Arg(1)
-    mbTrans114 := thrift.NewTMemoryBufferLen(len(arg113))
-    defer mbTrans114.Close()
-    _, err115 := mbTrans114.WriteString(arg113)
-    if err115 != nil {
+    arg164 := flag.Arg(1)
+    mbTrans165 := thrift.NewTMemoryBufferLen(len(arg164))
+    defer mbTrans165.Close()
+    _, err166 := mbTrans165.WriteString(arg164)
+    if err166 != nil {
       Usage()
       return
     }
-    factory116 := thrift.NewTJSONProtocolFactory()
-    jsProt117 := factory116.GetProtocol(mbTrans114)
+    factory167 := thrift.NewTJSONProtocolFactory()
+    jsProt168 := factory167.GetProtocol(mbTrans165)
     argvalue0 := aurora.NewJobUpdateQuery()
-    err118 := argvalue0.Read(jsProt117)
-    if err118 != nil {
+    err169 := argvalue0.Read(context.Background(), jsProt168)
+    if err169 != nil {
       Usage()
       return
     }
@@ -349,19 +349,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
       flag.Usage()
     }
-    arg119 := flag.Arg(1)
-    mbTrans120 := thrift.NewTMemoryBufferLen(len(arg119))
-    defer mbTrans120.Close()
-    _, err121 := mbTrans120.WriteString(arg119)
-    if err121 != nil {
+    arg170 := flag.Arg(1)
+    mbTrans171 := thrift.NewTMemoryBufferLen(len(arg170))
+    defer mbTrans171.Close()
+    _, err172 := mbTrans171.WriteString(arg170)
+    if err172 != nil {
       Usage()
       return
     }
-    factory122 := thrift.NewTJSONProtocolFactory()
-    jsProt123 := factory122.GetProtocol(mbTrans120)
+    factory173 := thrift.NewTJSONProtocolFactory()
+    jsProt174 := factory173.GetProtocol(mbTrans171)
     argvalue0 := aurora.NewJobUpdateQuery()
-    err124 := argvalue0.Read(jsProt123)
-    if err124 != nil {
+    err175 := argvalue0.Read(context.Background(), jsProt174)
+    if err175 != nil {
       Usage()
       return
     }
@@ -374,19 +374,19 @@ func main() {
       fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
       flag.Usage()
     }
-    arg125 := flag.Arg(1)
-    mbTrans126 := thrift.NewTMemoryBufferLen(len(arg125))
-    defer mbTrans126.Close()
-    _, err127 := mbTrans126.WriteString(arg125)
-    if err127 != nil {
+    arg176 := flag.Arg(1)
+    mbTrans177 := thrift.NewTMemoryBufferLen(len(arg176))
+    defer mbTrans177.Close()
+    _, err178 := mbTrans177.WriteString(arg176)
+    if err178 != nil {
       Usage()
       return
     }
-    factory128 := thrift.NewTJSONProtocolFactory()
-    jsProt129 := factory128.GetProtocol(mbTrans126)
+    factory179 := thrift.NewTJSONProtocolFactory()
+    jsProt180 := factory179.GetProtocol(mbTrans177)
     argvalue0 := aurora.NewJobUpdateRequest()
-    err130 := argvalue0.Read(jsProt129)
-    if err130 != nil {
+    err181 := argvalue0.Read(context.Background(), jsProt180)
+    if err181 != nil {
       Usage()
       return
     }

generateBindings.sh

@@ -1,6 +1,6 @@
 #! /bin/bash
 
-THRIFT_VER=0.12.0
+THRIFT_VER=0.14.0
 
 if [[ $(thrift -version | grep -e $THRIFT_VER -c) -ne 1 ]]; then
     echo "Warning: This wrapper has only been tested with version" $THRIFT_VER;

go.mod

@@ -1,12 +1,10 @@
 module github.com/aurora-scheduler/gorealis/v2
 
 require (
-	github.com/apache/thrift v0.12.0
+	github.com/apache/thrift v0.14.0
 	github.com/pkg/errors v0.9.1
 	github.com/samuel/go-zookeeper v0.0.0-20171117190445-471cd4e61d7a
-	github.com/stretchr/testify v1.5.0
+	github.com/stretchr/testify v1.7.0
 )
 
-replace github.com/apache/thrift v0.12.0 => github.com/ridv/thrift v0.12.2
-
-go 1.13
+go 1.16

go.sum

@@ -0,0 +1,22 @@
+github.com/apache/thrift v0.14.0 h1:vqZ2DP42i8th2OsgCcYZkirtbzvpZEFx53LiWDJXIAs=
+github.com/apache/thrift v0.14.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/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/samuel/go-zookeeper v0.0.0-20171117190445-471cd4e61d7a h1:EYL2xz/Zdo0hyqdZMXR4lmT2O11jDLTPCEqIe/FR6W4=
+github.com/samuel/go-zookeeper v0.0.0-20171117190445-471cd4e61d7a/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E=
+github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.5.0 h1:DMOzIV76tmoDNE9pX6RSN0aDtCYeCg5VueieJaAo1uw=
+github.com/stretchr/testify v1.5.0/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+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.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

helpers.go

@@ -0,0 +1,23 @@
+package realis
+
+import (
+	"context"
+
+	"github.com/aurora-scheduler/gorealis/v2/gen-go/apache/aurora"
+)
+
+func (r *Client) JobExists(key aurora.JobKey) (bool, error) {
+	resp, err := r.client.GetConfigSummary(context.TODO(), &key)
+	if err != nil {
+		return false, err
+	}
+
+	return resp != nil &&
+			resp.GetResult_() != nil &&
+			resp.GetResult_().GetConfigSummaryResult_() != nil &&
+			resp.GetResult_().GetConfigSummaryResult_().GetSummary() != nil &&
+			resp.GetResult_().GetConfigSummaryResult_().GetSummary().GetGroups() != nil &&
+			len(resp.GetResult_().GetConfigSummaryResult_().GetSummary().GetGroups()) > 0 &&
+			resp.GetResponseCode() == aurora.ResponseCode_OK,
+		nil
+}

job.go

@@ -156,6 +156,16 @@ func (j *AuroraJob) IsService(isService bool) *AuroraJob {
 	return j
 }
 
+func (j *AuroraJob) Priority(priority int32) *AuroraJob {
+	j.task.Priority(priority)
+	return j
+}
+
+func (j *AuroraJob) Production(production bool) *AuroraJob {
+	j.task.Production(production)
+	return j
+}
+
 func (j *AuroraJob) TaskConfig() *aurora.TaskConfig {
 	return j.task.TaskConfig()
 }

jobUpdate.go

@@ -31,32 +31,36 @@ type JobUpdate struct {
 func NewJobUpdate() *JobUpdate {
 	newTask := NewTask()
 
-	req := aurora.JobUpdateRequest{}
-	req.TaskConfig = newTask.TaskConfig()
-	req.Settings = newUpdateSettings()
-
-	return &JobUpdate{task: newTask, request: &req}
+	return &JobUpdate{
+		task:    newTask,
+		request: &aurora.JobUpdateRequest{TaskConfig: newTask.TaskConfig(), Settings: newUpdateSettings()},
+	}
 }
 
+// Creates an update with default values using an AuroraTask as the underlying task configuration.
+// This function has a high level understanding of Aurora Tasks and thus will support copying a task that is configured
+// to use Thermos.
 func JobUpdateFromAuroraTask(task *AuroraTask) *JobUpdate {
 	newTask := task.Clone()
 
-	req := aurora.JobUpdateRequest{}
-	req.TaskConfig = newTask.TaskConfig()
-	req.Settings = newUpdateSettings()
-
-	return &JobUpdate{task: newTask, request: &req}
+	return &JobUpdate{
+		task:    newTask,
+		request: &aurora.JobUpdateRequest{TaskConfig: newTask.TaskConfig(), Settings: newUpdateSettings()},
+	}
 }
 
+// JobUpdateFromConfig creates an update with default values using an aurora.TaskConfig
+// primitive as the underlying task configuration.
+// This function should not be used unless the implications of using a primitive value are understood.
+// For example, the primitive has no concept of Thermos.
 func JobUpdateFromConfig(task *aurora.TaskConfig) *JobUpdate {
 	// Perform a deep copy to avoid unexpected behavior
 	newTask := TaskFromThrift(task)
 
-	req := aurora.JobUpdateRequest{}
-	req.TaskConfig = newTask.TaskConfig()
-	req.Settings = newUpdateSettings()
-
-	return &JobUpdate{task: newTask, request: &req}
+	return &JobUpdate{
+		task:    newTask,
+		request: &aurora.JobUpdateRequest{TaskConfig: newTask.TaskConfig(), Settings: newUpdateSettings()},
+	}
 }
 
 // Set instance count the job will have after the update.
@@ -73,7 +77,7 @@ func (j *JobUpdate) BatchSize(size int32) *JobUpdate {
 
 // Minimum number of seconds a shard must remain in RUNNING state before considered a success.
 func (j *JobUpdate) WatchTime(timeout time.Duration) *JobUpdate {
-	j.request.Settings.MinWaitInInstanceRunningMs = int32(timeout.Seconds() * 1000)
+	j.request.Settings.MinWaitInInstanceRunningMs = int32(timeout.Milliseconds())
 	return j
 }
 
@@ -106,9 +110,42 @@ func (j *JobUpdate) PulseIntervalTimeout(timeout time.Duration) *JobUpdate {
 	j.request.Settings.BlockIfNoPulsesAfterMs = thrift.Int32Ptr(int32(timeout.Seconds() * 1000))
 	return j
 }
+func (j *JobUpdate) BatchUpdateStrategy(autoPause bool, batchSize int32) *JobUpdate {
+	j.request.Settings.UpdateStrategy = &aurora.JobUpdateStrategy{
+		BatchStrategy: &aurora.BatchJobUpdateStrategy{GroupSize: batchSize, AutopauseAfterBatch: autoPause},
+	}
+	return j
+}
+
+func (j *JobUpdate) QueueUpdateStrategy(groupSize int32) *JobUpdate {
+	j.request.Settings.UpdateStrategy = &aurora.JobUpdateStrategy{
+		QueueStrategy: &aurora.QueueJobUpdateStrategy{GroupSize: groupSize},
+	}
+	return j
+}
+
+func (j *JobUpdate) VariableBatchStrategy(autoPause bool, batchSizes ...int32) *JobUpdate {
+	j.request.Settings.UpdateStrategy = &aurora.JobUpdateStrategy{
+		VarBatchStrategy: &aurora.VariableBatchJobUpdateStrategy{GroupSizes: batchSizes, AutopauseAfterBatch: autoPause},
+	}
+	return j
+}
+
+// SlaAware makes the scheduler enforce the SLA Aware policy if the job meets the SLA awareness criteria.
+// By default, the scheduler will only apply SLA Awareness to jobs in the production tier with 20 or more instances.
+func (j *JobUpdate) SlaAware(slaAware bool) *JobUpdate {
+	j.request.Settings.SlaAware = &slaAware
+	return j
+}
+
+// AddInstanceRange allows updates to only touch a certain specific range of instances
+func (j *JobUpdate) AddInstanceRange(first, last int32) *JobUpdate {
+	j.request.Settings.UpdateOnlyTheseInstances = append(j.request.Settings.UpdateOnlyTheseInstances,
+		&aurora.Range{First: first, Last: last})
+	return j
+}
 
 func newUpdateSettings() *aurora.JobUpdateSettings {
-
 	us := aurora.JobUpdateSettings{}
 	// Mirrors defaults set by Pystachio
 	us.UpdateOnlyTheseInstances = []*aurora.Range{}
@@ -174,7 +211,7 @@ func (j *JobUpdate) Tier(tier string) *JobUpdate {
 	return j
 }
 
-func (j *JobUpdate) MaxFailure(maxFail int32) *JobUpdate {
+func (j *JobUpdate) TaskMaxFailure(maxFail int32) *JobUpdate {
 	j.task.MaxFailure(maxFail)
 	return j
 }
@@ -184,6 +221,16 @@ func (j *JobUpdate) IsService(isService bool) *JobUpdate {
 	return j
 }
 
+func (j *JobUpdate) Priority(priority int32) *JobUpdate {
+	j.task.Priority(priority)
+	return j
+}
+
+func (j *JobUpdate) Production(production bool) *JobUpdate {
+	j.task.Production(production)
+	return j
+}
+
 func (j *JobUpdate) TaskConfig() *aurora.TaskConfig {
 	return j.task.TaskConfig()
 }

monitors.go

@@ -244,3 +244,69 @@ func (c *Client) MonitorHostMaintenance(hosts []string,
 		}
 	}
 }
+
+// MonitorAutoPausedUpdate is a special monitor for auto pause enabled batch updates. This monitor ensures that the update
+// being monitored is capable of auto pausing and has auto pausing enabled. After verifying this information,
+// the monitor watches for the job to enter the ROLL_FORWARD_PAUSED state and calculates the current batch
+// the update is in using information from the update configuration.
+func (c *Client) MonitorAutoPausedUpdate(key aurora.JobUpdateKey, interval, timeout time.Duration) (int, error) {
+	key.Job = &aurora.JobKey{
+		Role:        key.Job.Role,
+		Environment: key.Job.Environment,
+		Name:        key.Job.Name,
+	}
+	query := aurora.JobUpdateQuery{
+		UpdateStatuses: aurora.ACTIVE_JOB_UPDATE_STATES,
+		Limit:          1,
+		Key:            &key,
+	}
+
+	updateDetails, err := c.JobUpdateDetails(query)
+	if err != nil {
+		return -1, errors.Wrap(err, "unable to get information about update")
+	}
+
+	if len(updateDetails) == 0 {
+		return -1, errors.Errorf("details for update could not be found")
+	}
+
+	updateStrategy := updateDetails[0].Update.Instructions.Settings.UpdateStrategy
+
+	var batchSizes []int32
+	switch {
+	case updateStrategy.IsSetVarBatchStrategy():
+		batchSizes = updateStrategy.VarBatchStrategy.GroupSizes
+		if !updateStrategy.VarBatchStrategy.AutopauseAfterBatch {
+			return -1, errors.Errorf("update does not have auto pause enabled")
+		}
+	case updateStrategy.IsSetBatchStrategy():
+		batchSizes = []int32{updateStrategy.BatchStrategy.GroupSize}
+		if !updateStrategy.BatchStrategy.AutopauseAfterBatch {
+			return -1, errors.Errorf("update does not have auto pause enabled")
+		}
+	default:
+		return -1, errors.Errorf("update is not using a batch update strategy")
+	}
+
+	query.UpdateStatuses = append(TerminalUpdateStates(), aurora.JobUpdateStatus_ROLL_FORWARD_PAUSED)
+	summary, err := c.MonitorJobUpdateQuery(query, interval, timeout)
+	if err != nil {
+		return -1, err
+	}
+
+	// Summary 0 is assumed to exist because MonitorJobUpdateQuery will return an error if there is no summaries
+	if !(summary[0].State.Status == aurora.JobUpdateStatus_ROLL_FORWARD_PAUSED ||
+		summary[0].State.Status == aurora.JobUpdateStatus_ROLLED_FORWARD) {
+		return -1, errors.Errorf("update is in a terminal state %v", summary[0].State.Status)
+	}
+
+	updatingInstances := make(map[int32]struct{})
+	for _, e := range updateDetails[0].InstanceEvents {
+		// We only care about INSTANCE_UPDATING actions because we only care that they've been attempted
+		if e != nil && e.GetAction() == aurora.JobUpdateAction_INSTANCE_UPDATING {
+			updatingInstances[e.GetInstanceId()] = struct{}{}
+		}
+	}
+
+	return calculateCurrentBatch(int32(len(updatingInstances)), batchSizes), nil
+}

offer.go

@@ -0,0 +1,434 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package realis
+
+import (
+	"bytes"
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/aurora-scheduler/gorealis/v2/gen-go/apache/aurora"
+)
+
+// Offers on [aurora-scheduler]/offers endpoint
+type Offer struct {
+	ID struct {
+		Value string `json:"value"`
+	} `json:"id"`
+	FrameworkID struct {
+		Value string `json:"value"`
+	} `json:"framework_id"`
+	AgentID struct {
+		Value string `json:"value"`
+	} `json:"agent_id"`
+	Hostname string `json:"hostname"`
+	URL      struct {
+		Scheme  string `json:"scheme"`
+		Address struct {
+			Hostname string `json:"hostname"`
+			IP       string `json:"ip"`
+			Port     int    `json:"port"`
+		} `json:"address"`
+		Path  string        `json:"path"`
+		Query []interface{} `json:"query"`
+	} `json:"url"`
+	Resources []struct {
+		Name   string `json:"name"`
+		Type   string `json:"type"`
+		Ranges struct {
+			Range []struct {
+				Begin int `json:"begin"`
+				End   int `json:"end"`
+			} `json:"range"`
+		} `json:"ranges,omitempty"`
+		Role         string        `json:"role"`
+		Reservations []interface{} `json:"reservations"`
+		Scalar       struct {
+			Value float64 `json:"value"`
+		} `json:"scalar,omitempty"`
+	} `json:"resources"`
+	Attributes []struct {
+		Name string `json:"name"`
+		Type string `json:"type"`
+		Text struct {
+			Value string `json:"value"`
+		} `json:"text"`
+	} `json:"attributes"`
+	ExecutorIds []struct {
+		Value string `json:"value"`
+	} `json:"executor_ids"`
+}
+
+// hosts on [aurora-scheduler]/maintenance endpoint
+type MaintenanceList struct {
+	Drained   []string            `json:"DRAINED"`
+	Scheduled []string            `json:"SCHEDULED"`
+	Draining  map[string][]string `json:"DRAINING"`
+}
+
+type OfferCount map[float64]int64
+type OfferGroupReport map[string]OfferCount
+type OfferReport map[string]OfferGroupReport
+
+// MaintenanceHosts list all the hosts under maintenance
+func (c *Client) MaintenanceHosts() ([]string, error) {
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: c.config.insecureSkipVerify},
+	}
+
+	request := &http.Client{Transport: tr}
+
+	resp, err := request.Get(fmt.Sprintf("%s/maintenance", c.GetSchedulerURL()))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	buf := new(bytes.Buffer)
+	if _, err := buf.ReadFrom(resp.Body); err != nil {
+		return nil, err
+	}
+
+	var list MaintenanceList
+
+	if err := json.Unmarshal(buf.Bytes(), &list); err != nil {
+		return nil, err
+	}
+
+	hosts := append(list.Drained, list.Scheduled...)
+
+	for drainingHost := range list.Draining {
+		hosts = append(hosts, drainingHost)
+	}
+
+	return hosts, nil
+}
+
+// Offers pulls data from /offers endpoint
+func (c *Client) Offers() ([]Offer, error) {
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: c.config.insecureSkipVerify},
+	}
+
+	request := &http.Client{Transport: tr}
+
+	resp, err := request.Get(fmt.Sprintf("%s/offers", c.GetSchedulerURL()))
+	if err != nil {
+		return []Offer{}, err
+	}
+	defer resp.Body.Close()
+
+	buf := new(bytes.Buffer)
+	if _, err := buf.ReadFrom(resp.Body); err != nil {
+		return nil, err
+	}
+
+	var offers []Offer
+
+	if err := json.Unmarshal(buf.Bytes(), &offers); err != nil {
+		return []Offer{}, err
+	}
+
+	return offers, nil
+}
+
+// AvailOfferReport returns a detailed summary of offers available for use.
+// For example, 2 nodes offer 32 cpus and 10 nodes offer 1 cpus.
+func (c *Client) AvailOfferReport() (OfferReport, error) {
+	maintHosts, err := c.MaintenanceHosts()
+	if err != nil {
+		return nil, err
+	}
+
+	maintHostSet := map[string]bool{}
+	for _, h := range maintHosts {
+		maintHostSet[h] = true
+	}
+
+	// Get a list of offers
+	offers, err := c.Offers()
+	if err != nil {
+		return nil, err
+	}
+
+	report := OfferReport{}
+
+	for _, o := range offers {
+		if maintHostSet[o.Hostname] {
+			continue
+		}
+
+		group := "non-dedicated"
+		for _, a := range o.Attributes {
+			if a.Name == "dedicated" {
+				group = a.Text.Value
+				break
+			}
+		}
+
+		if _, ok := report[group]; !ok {
+			report[group] = map[string]OfferCount{}
+		}
+
+		for _, r := range o.Resources {
+
+			if _, ok := report[group][r.Name]; !ok {
+				report[group][r.Name] = OfferCount{}
+			}
+
+			val := 0.0
+			switch r.Type {
+			case "SCALAR":
+				val = r.Scalar.Value
+			case "RANGES":
+				for _, pr := range r.Ranges.Range {
+					val += float64(pr.End - pr.Begin + 1)
+				}
+			default:
+				return nil, fmt.Errorf("%s is not supported", r.Type)
+			}
+
+			report[group][r.Name][val]++
+		}
+	}
+
+	return report, nil
+}
+
+// FitTasks computes the number tasks can be fit in a list of offer
+func (c *Client) FitTasks(taskConfig *aurora.TaskConfig, offers []Offer) (int64, error) {
+	// count the number of tasks per limit contraint: limit.name -> limit.value -> count
+	limitCounts := map[string]map[string]int64{}
+	for _, c := range taskConfig.Constraints {
+		if c.Constraint.Limit != nil {
+			limitCounts[c.Name] = map[string]int64{}
+		}
+	}
+
+	request := ResourcesToMap(taskConfig.Resources)
+
+	// validate resource request
+	if len(request) == 0 {
+		return -1, fmt.Errorf("Resource request %v must not be empty", request)
+	}
+
+	isValid := false
+	for _, resVal := range request {
+		if resVal > 0 {
+			isValid = true
+			break
+		}
+	}
+
+	if !isValid {
+		return -1, fmt.Errorf("Resource request %v is not valid", request)
+	}
+
+	// pull the list of hosts under maintenance
+	maintHosts, err := c.MaintenanceHosts()
+	if err != nil {
+		return -1, err
+	}
+
+	maintHostSet := map[string]bool{}
+	for _, h := range maintHosts {
+		maintHostSet[h] = true
+	}
+
+	numTasks := int64(0)
+
+	for _, o := range offers {
+		// skip the hosts under maintenance
+		if maintHostSet[o.Hostname] {
+			continue
+		}
+
+		numTasksPerOffer := int64(-1)
+
+		for resName, resVal := range request {
+			// skip as we can fit a infinite number of tasks with 0 demand.
+			if resVal == 0 {
+				continue
+			}
+
+			avail := 0.0
+			for _, r := range o.Resources {
+				if r.Name != resName {
+					continue
+				}
+
+				switch r.Type {
+				case "SCALAR":
+					avail = r.Scalar.Value
+				case "RANGES":
+					for _, pr := range r.Ranges.Range {
+						avail += float64(pr.End - pr.Begin + 1)
+					}
+				default:
+					return -1, fmt.Errorf("%s is not supported", r.Type)
+				}
+			}
+
+			numTasksPerResource := int64(avail / resVal)
+
+			if numTasksPerResource < numTasksPerOffer || numTasksPerOffer < 0 {
+				numTasksPerOffer = numTasksPerResource
+			}
+		}
+
+		numTasks += fitConstraints(taskConfig, &o, limitCounts, numTasksPerOffer)
+	}
+
+	return numTasks, nil
+}
+
+func fitConstraints(taskConfig *aurora.TaskConfig,
+	offer *Offer,
+	limitCounts map[string]map[string]int64,
+	numTasksPerOffer int64) int64 {
+
+	// check dedicated attributes vs. constraints
+	if !isDedicated(offer, taskConfig.Job.Role, taskConfig.Constraints) {
+		return 0
+	}
+
+	limitConstraints := []*aurora.Constraint{}
+
+	for _, c := range taskConfig.Constraints {
+		// look for corresponding attribute
+		attFound := false
+		for _, a := range offer.Attributes {
+			if a.Name == c.Name {
+				attFound = true
+			}
+		}
+
+		// constraint not found in offer's attributes
+		if !attFound {
+			return 0
+		}
+
+		if c.Constraint.Value != nil && !valueConstraint(offer, c) {
+			// value constraint is not satisfied
+			return 0
+		} else if c.Constraint.Limit != nil {
+			limitConstraints = append(limitConstraints, c)
+			limit := limitConstraint(offer, c, limitCounts)
+
+			if numTasksPerOffer > limit && limit >= 0 {
+				numTasksPerOffer = limit
+			}
+		}
+	}
+
+	// update limitCounts
+	for _, c := range limitConstraints {
+		for _, a := range offer.Attributes {
+			if a.Name == c.Name {
+				limitCounts[a.Name][a.Text.Value] += numTasksPerOffer
+			}
+		}
+	}
+
+	return numTasksPerOffer
+}
+
+func isDedicated(offer *Offer, role string, constraints []*aurora.Constraint) bool {
+	// get all dedicated attributes of an offer
+	dedicatedAtts := map[string]bool{}
+	for _, a := range offer.Attributes {
+		if a.Name == "dedicated" {
+			dedicatedAtts[a.Text.Value] = true
+		}
+	}
+
+	if len(dedicatedAtts) == 0 {
+		return true
+	}
+
+	// check if constraints are matching dedicated attributes
+	matched := false
+	for _, c := range constraints {
+		if c.Name == "dedicated" && c.Constraint.Value != nil {
+			found := false
+
+			for _, v := range c.Constraint.Value.Values {
+				if dedicatedAtts[v] && strings.HasPrefix(v, fmt.Sprintf("%s/", role)) {
+					found = true
+					break
+				}
+			}
+
+			if found {
+				matched = true
+			} else {
+				return false
+			}
+		}
+	}
+
+	return matched
+}
+
+// valueConstraint checks Value Contraints of task if the are matched by the offer.
+// more details can be found here https://aurora.apache.org/documentation/latest/features/constraints/
+func valueConstraint(offer *Offer, constraint *aurora.Constraint) bool {
+	matched := false
+
+	for _, a := range offer.Attributes {
+		if a.Name == constraint.Name {
+			for _, v := range constraint.Constraint.Value.Values {
+				matched = (a.Text.Value == v && !constraint.Constraint.Value.Negated) ||
+					(a.Text.Value != v && constraint.Constraint.Value.Negated)
+
+				if matched {
+					break
+				}
+			}
+
+			if matched {
+				break
+			}
+		}
+	}
+
+	return matched
+}
+
+// limitConstraint limits the number of pods on a group which has the same attribute.
+// more details can be found here https://aurora.apache.org/documentation/latest/features/constraints/
+func limitConstraint(offer *Offer, constraint *aurora.Constraint, limitCounts map[string]map[string]int64) int64 {
+	limit := int64(-1)
+	for _, a := range offer.Attributes {
+		// limit constraint found
+		if a.Name == constraint.Name {
+			curr := limitCounts[a.Name][a.Text.Value]
+			currLimit := int64(constraint.Constraint.Limit.Limit)
+
+			if curr >= currLimit {
+				return 0
+			}
+
+			if currLimit-curr < limit || limit < 0 {
+				limit = currLimit - curr
+			}
+		}
+	}
+
+	return limit
+}

realis.go

@@ -36,7 +36,7 @@ import (
 	"github.com/pkg/errors"
 )
 
-const VERSION = "2.0.1"
+const VERSION = "2.28.0"
 
 type Client struct {
 	config         *clientConfig
@@ -147,6 +147,8 @@ func NewClient(options ...ClientOption) (*Client, error) {
 		return nil, errors.New("incomplete Options -- url, cluster.json, or Zookeeper address required")
 	}
 
+	config.url = url
+
 	url, err = validateAuroraAddress(url)
 	if err != nil {
 		return nil, errors.Wrap(err, "unable to create realis object, invalid url")
@@ -313,11 +315,13 @@ func (c *Client) GetInstanceIds(key aurora.JobKey, states []aurora.ScheduleStatu
 		Statuses:    states,
 	}
 
-	c.logger.DebugPrintf("GetTasksWithoutConfigs Thrift Payload: %+v\n", taskQ)
+	c.logger.DebugPrintf("GetInstanceIds Thrift Payload: %+v\n", taskQ)
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.GetTasksWithoutConfigs(context.TODO(), taskQ)
-	})
+	},
+		nil,
+	)
 
 	// If we encountered an error we couldn't recover from by retrying, return an error to the user
 	if retryErr != nil {
@@ -339,8 +343,13 @@ func (c *Client) GetJobUpdateSummaries(jobUpdateQuery *aurora.JobUpdateQuery) (*
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.readonlyClient.GetJobUpdateSummaries(context.TODO(), jobUpdateQuery)
-	})
+	},
+		nil,
+	)
 
+	if resp == nil || resp.GetResult_() == nil || resp.GetResult_().GetGetJobUpdateSummariesResult_() == nil {
+		return nil, errors.New("unexpected response from scheduler")
+	}
 	if retryErr != nil {
 		return nil, errors.Wrap(retryErr, "error getting job update summaries from Aurora Scheduler")
 	}
@@ -348,23 +357,39 @@ func (c *Client) GetJobUpdateSummaries(jobUpdateQuery *aurora.JobUpdateQuery) (*
 	return resp.GetResult_().GetGetJobUpdateSummariesResult_(), nil
 }
 
-func (c *Client) GetJobs(role string) (*aurora.GetJobsResult_, error) {
+func (c *Client) GetJobSummary(role string) (*aurora.JobSummaryResult_, error) {
 
-	var result *aurora.GetJobsResult_
+	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
+		return c.readonlyClient.GetJobSummary(context.TODO(), role)
+	},
+		nil,
+	)
+	if resp == nil || resp.GetResult_() == nil || resp.GetResult_().GetJobSummaryResult_() == nil {
+		return nil, errors.New("unexpected response from scheduler")
+	}
+	if retryErr != nil {
+		return nil, errors.Wrap(retryErr, "error getting job summaries from Aurora Scheduler")
+	}
+
+	return resp.GetResult_().GetJobSummaryResult_(), nil
+}
+
+func (c *Client) GetJobs(role string) (*aurora.GetJobsResult_, error) {
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.readonlyClient.GetJobs(context.TODO(), role)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
-		return result, errors.Wrap(retryErr, "error getting Jobs from Aurora Scheduler")
+		return nil, errors.Wrap(retryErr, "error getting Jobs from Aurora Scheduler")
+	}
+	if resp == nil || resp.GetResult_() == nil {
+		return nil, errors.New("unexpected response from scheduler")
 	}
 
-	if resp.GetResult_() != nil {
-		result = resp.GetResult_().GetJobsResult_
-	}
-
-	return result, nil
+	return resp.GetResult_().GetJobsResult_, nil
 }
 
 // Kill specific instances of a job. Returns true, nil if a task was actually killed as a result of this API call.
@@ -374,19 +399,19 @@ func (c *Client) KillInstances(key aurora.JobKey, instances ...int32) (bool, err
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.KillTasks(context.TODO(), &key, instances, "")
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return false, errors.Wrap(retryErr, "error sending Kill command to Aurora Scheduler")
 	}
 
-	if len(resp.GetDetails()) > 0 {
+	if resp == nil || len(resp.GetDetails()) > 0 {
 		c.logger.Println("KillTasks was called but no tasks killed as a result.")
 		return false, nil
-	} else {
-		return true, nil
 	}
-
+	return true, nil
 }
 
 func (c *Client) RealisConfig() *clientConfig {
@@ -401,7 +426,9 @@ func (c *Client) KillJob(key aurora.JobKey) error {
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		// Giving the KillTasks thrift call an empty set tells the Aurora scheduler to kill all active shards
 		return c.client.KillTasks(context.TODO(), &key, nil, "")
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "error sending Kill command to Aurora Scheduler")
@@ -423,9 +450,27 @@ func (c *Client) CreateJob(auroraJob *AuroraJob) error {
 		return errors.Wrap(err, "unable to create Thermos payload")
 	}
 
-	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
-		return c.client.CreateJob(context.TODO(), auroraJob.JobConfig())
-	})
+	// Response is checked by the thrift retry code
+	_, retryErr := c.thriftCallWithRetries(
+		false,
+		func() (*aurora.Response, error) {
+			return c.client.CreateJob(context.TODO(), auroraJob.JobConfig())
+		},
+		// On a client timeout, attempt to verify that payload made to the Scheduler by
+		// trying to get the config summary for the job key
+		func() (*aurora.Response, bool) {
+			exists, err := c.JobExists(auroraJob.JobKey())
+			if err != nil {
+				c.logger.Print("verification failed ", err)
+			}
+
+			if exists {
+				return &aurora.Response{ResponseCode: aurora.ResponseCode_OK}, true
+			}
+
+			return nil, false
+		},
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "error sending Create command to Aurora Scheduler")
@@ -456,7 +501,9 @@ func (c *Client) ScheduleCronJob(auroraJob *AuroraJob) error {
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.ScheduleCronJob(context.TODO(), auroraJob.JobConfig())
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "error sending Cron AuroraJob Schedule message to Aurora Scheduler")
@@ -470,7 +517,9 @@ func (c *Client) DescheduleCronJob(key aurora.JobKey) error {
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.DescheduleCronJob(context.TODO(), &key)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "error sending Cron AuroraJob De-schedule message to Aurora Scheduler")
@@ -486,7 +535,9 @@ func (c *Client) StartCronJob(key aurora.JobKey) error {
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.StartCronJob(context.TODO(), &key)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "error sending Start Cron AuroraJob  message to Aurora Scheduler")
@@ -501,7 +552,9 @@ func (c *Client) RestartInstances(key aurora.JobKey, instances ...int32) error {
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.RestartShards(context.TODO(), &key, instances)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "error sending Restart command to Aurora Scheduler")
@@ -522,16 +575,17 @@ func (c *Client) RestartJob(key aurora.JobKey) error {
 	if len(instanceIds) > 0 {
 		_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 			return c.client.RestartShards(context.TODO(), &key, instanceIds)
-		})
+		},
+			nil,
+		)
 
 		if retryErr != nil {
 			return errors.Wrap(retryErr, "error sending Restart command to Aurora Scheduler")
 		}
 
 		return nil
-	} else {
-		return errors.New("no tasks in the Active state")
 	}
+	return errors.New("no tasks in the Active state")
 }
 
 // Update all tasks under a job configuration. Currently gorealis doesn't support for canary deployments.
@@ -543,34 +597,80 @@ func (c *Client) StartJobUpdate(updateJob *JobUpdate, message string) (*aurora.S
 
 	c.logger.DebugPrintf("StartJobUpdate Thrift Payload: %+v %v\n", updateJob, message)
 
-	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
-		return c.client.StartJobUpdate(nil, updateJob.request, message)
-	})
+	resp, retryErr := c.thriftCallWithRetries(false,
+		func() (*aurora.Response, error) {
+			return c.client.StartJobUpdate(context.TODO(), updateJob.request, message)
+		},
+		func() (*aurora.Response, bool) {
+			key := updateJob.JobKey()
+			summariesResp, err := c.readonlyClient.GetJobUpdateSummaries(
+				context.TODO(),
+				&aurora.JobUpdateQuery{
+					JobKey:         &key,
+					UpdateStatuses: aurora.ACTIVE_JOB_UPDATE_STATES,
+					Limit:          1,
+				})
+
+			if err != nil {
+				c.logger.Print("verification failed ", err)
+				return nil, false
+			}
+
+			summaries := response.JobUpdateSummaries(summariesResp)
+			if len(summaries) == 0 {
+				return nil, false
+			}
+
+			return &aurora.Response{
+				ResponseCode: aurora.ResponseCode_OK,
+				Result_: &aurora.Result_{
+					StartJobUpdateResult_: &aurora.StartJobUpdateResult_{
+						UpdateSummary: summaries[0],
+						Key:           summaries[0].Key,
+					},
+				},
+			}, true
+		},
+	)
 
 	if retryErr != nil {
+		// A timeout took place when attempting this call, attempt to recover
+		if IsTimeout(retryErr) {
+			return nil, retryErr
+		}
+
 		return nil, errors.Wrap(retryErr, "error sending StartJobUpdate command to Aurora Scheduler")
 	}
-
-	if resp.GetResult_() != nil && resp.GetResult_().GetStartJobUpdateResult_() != nil {
-		return resp.GetResult_().GetStartJobUpdateResult_(), nil
+	if resp == nil || resp.GetResult_() == nil || resp.GetResult_().GetStartJobUpdateResult_() == nil {
+		return nil, errors.New("unexpected response from scheduler")
 	}
-
-	return nil, errors.New("thrift error: Field in response is nil unexpectedly.")
+	return resp.GetResult_().GetStartJobUpdateResult_(), nil
 }
 
-// Abort AuroraJob Update on Aurora. Requires the updateId which can be obtained on the Aurora web UI.
+// AbortJobUpdate terminates a job update in the scheduler.
+// It requires the updateId which can be obtained on the Aurora web UI.
+// This API is meant to be synchronous. It will attempt to wait until the update transitions to the aborted state.
+// However, if the job update does not transition to the ABORT state an error will be returned.
 func (c *Client) AbortJobUpdate(updateKey aurora.JobUpdateKey, message string) error {
 
 	c.logger.DebugPrintf("AbortJobUpdate Thrift Payload: %+v %v\n", updateKey, message)
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.AbortJobUpdate(context.TODO(), &updateKey, message)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "error sending AbortJobUpdate command to Aurora Scheduler")
 	}
-	return nil
+	// Make this call synchronous by  blocking until it job has successfully transitioned to aborted
+	_, err := c.MonitorJobUpdateStatus(
+		updateKey,
+		[]aurora.JobUpdateStatus{aurora.JobUpdateStatus_ABORTED},
+		time.Second*5,
+		time.Minute)
+	return err
 }
 
 // Pause AuroraJob Update. UpdateID is returned from StartJobUpdate or the Aurora web UI.
@@ -590,7 +690,9 @@ func (c *Client) PauseJobUpdate(updateKey *aurora.JobUpdateKey, message string)
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.PauseJobUpdate(nil, updateKeyLocal, message)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "error sending PauseJobUpdate command to Aurora Scheduler")
@@ -617,7 +719,9 @@ func (c *Client) ResumeJobUpdate(updateKey aurora.JobUpdateKey, message string)
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.ResumeJobUpdate(context.TODO(), &updateKey, message)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "error sending ResumeJobUpdate command to Aurora Scheduler")
@@ -638,18 +742,19 @@ func (c *Client) PulseJobUpdate(updateKey aurora.JobUpdateKey) (aurora.JobUpdate
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.PulseJobUpdate(context.TODO(), &updateKey)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return aurora.JobUpdatePulseStatus(0), errors.Wrap(retryErr, "error sending PulseJobUpdate command to Aurora Scheduler")
 	}
 
-	if resp.GetResult_() != nil && resp.GetResult_().GetPulseJobUpdateResult_() != nil {
-		return resp.GetResult_().GetPulseJobUpdateResult_().GetStatus(), nil
-	} else {
-		return aurora.JobUpdatePulseStatus(0), errors.New("thrift error, field was nil unexpectedly")
+	if resp == nil || resp.GetResult_() == nil || resp.GetResult_().GetPulseJobUpdateResult_() == nil {
+		return aurora.JobUpdatePulseStatus(0), errors.New("unexpected response from scheduler")
 	}
 
+	return resp.GetResult_().GetPulseJobUpdateResult_().GetStatus(), nil
 }
 
 // Scale up the number of instances under a job configuration using the configuration for specific
@@ -666,7 +771,9 @@ func (c *Client) AddInstances(instKey aurora.InstanceKey, count int32) error {
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.AddInstances(context.TODO(), &instKey, count)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "error sending AddInstances command to Aurora Scheduler")
@@ -711,11 +818,16 @@ func (c *Client) GetTaskStatus(query *aurora.TaskQuery) ([]*aurora.ScheduledTask
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.GetTasksStatus(context.TODO(), query)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return nil, errors.Wrap(retryErr, "error querying Aurora Scheduler for task status")
 	}
+	if resp == nil {
+		return nil, errors.New("unexpected response from scheduler")
+	}
 
 	return response.ScheduleStatusResult(resp).GetTasks(), nil
 }
@@ -727,29 +839,32 @@ func (c *Client) GetPendingReason(query *aurora.TaskQuery) ([]*aurora.PendingRea
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.GetPendingReason(context.TODO(), query)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return nil, errors.Wrap(retryErr, "error querying Aurora Scheduler for pending Reasons")
 	}
 
-	var result []*aurora.PendingReason
-
-	if resp.GetResult_() != nil {
-		result = resp.GetResult_().GetGetPendingReasonResult_().GetReasons()
+	if resp == nil || resp.GetResult_() == nil || resp.GetResult_().GetGetPendingReasonResult_() == nil {
+		return nil, errors.New("unexpected response from scheduler")
 	}
 
-	return result, nil
+	return resp.GetResult_().GetGetPendingReasonResult_().GetReasons(), nil
 }
 
-// Get information about task including without a task configuration object
+// GetTasksWithoutConfigs gets information about task including without a task configuration object.
+// This is a more lightweight version of GetTaskStatus but contains less information as a result.
 func (c *Client) GetTasksWithoutConfigs(query *aurora.TaskQuery) ([]*aurora.ScheduledTask, error) {
 
 	c.logger.DebugPrintf("GetTasksWithoutConfigs Thrift Payload: %+v\n", query)
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.GetTasksWithoutConfigs(context.TODO(), query)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return nil, errors.Wrap(retryErr, "error querying Aurora Scheduler for task status without configs")
@@ -776,7 +891,9 @@ func (c *Client) FetchTaskConfig(instKey aurora.InstanceKey) (*aurora.TaskConfig
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.GetTasksStatus(context.TODO(), taskQ)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return nil, errors.Wrap(retryErr, "error querying Aurora Scheduler for task configuration")
@@ -802,17 +919,19 @@ func (c *Client) JobUpdateDetails(updateQuery aurora.JobUpdateQuery) ([]*aurora.
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.GetJobUpdateDetails(context.TODO(), &updateQuery)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return nil, errors.Wrap(retryErr, "unable to get job update details")
 	}
 
-	if resp.GetResult_() != nil && resp.GetResult_().GetGetJobUpdateDetailsResult_() != nil {
-		return resp.GetResult_().GetGetJobUpdateDetailsResult_().GetDetailsList(), nil
-	} else {
-		return nil, errors.New("unknown Thrift error, field is nil.")
+	if resp == nil || resp.GetResult_() == nil || resp.GetResult_().GetGetJobUpdateDetailsResult_() == nil {
+		return nil, errors.New("unexpected response from scheduler")
 	}
+
+	return resp.GetResult_().GetGetJobUpdateDetailsResult_().GetDetailsList(), nil
 }
 
 func (c *Client) RollbackJobUpdate(key aurora.JobUpdateKey, message string) error {
@@ -821,10 +940,16 @@ func (c *Client) RollbackJobUpdate(key aurora.JobUpdateKey, message string) erro
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.client.RollbackJobUpdate(context.TODO(), &key, message)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "unable to roll back job update")
 	}
 	return nil
 }
+
+func (c *Client) GetSchedulerURL() string {
+	return c.config.url
+}

realis_admin.go

@@ -37,17 +37,19 @@ func (c *Client) DrainHosts(hosts ...string) ([]*aurora.HostStatus, error) {
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.adminClient.DrainHosts(context.TODO(), drainList)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return nil, errors.Wrap(retryErr, "unable to recover connection")
 	}
 
-	if resp.GetResult_() != nil && resp.GetResult_().GetDrainHostsResult_() != nil {
-		return resp.GetResult_().GetDrainHostsResult_().GetStatuses(), nil
-	} else {
-		return nil, errors.New("thrift error: Field in response is nil unexpectedly.")
+	if resp == nil || resp.GetResult_() == nil || resp.GetResult_().GetDrainHostsResult_() == nil {
+		return nil, errors.New("unexpected response from scheduler")
 	}
+
+	return resp.GetResult_().GetDrainHostsResult_().GetStatuses(), nil
 }
 
 // Start SLA Aware Drain.
@@ -59,6 +61,18 @@ func (c *Client) SLADrainHosts(policy *aurora.SlaPolicy, timeout int64, hosts ..
 		return nil, errors.New("no hosts provided to drain")
 	}
 
+	if policy == nil || policy.CountSetFieldsSlaPolicy() == 0 {
+		policy = &defaultSlaPolicy
+		c.logger.Printf("Warning: start draining with default sla policy %v", policy)
+	}
+
+	if timeout < 0 {
+		c.logger.Printf("Warning: timeout %d secs is invalid, draining with default timeout %d secs",
+			timeout,
+			defaultSlaDrainTimeoutSecs)
+		timeout = defaultSlaDrainTimeoutSecs
+	}
+
 	drainList := aurora.NewHosts()
 	drainList.HostNames = hosts
 
@@ -66,17 +80,19 @@ func (c *Client) SLADrainHosts(policy *aurora.SlaPolicy, timeout int64, hosts ..
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.adminClient.SlaDrainHosts(context.TODO(), drainList, policy, timeout)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return nil, errors.Wrap(retryErr, "unable to recover connection")
 	}
 
-	if resp.GetResult_() != nil && resp.GetResult_().GetDrainHostsResult_() != nil {
-		return resp.GetResult_().GetDrainHostsResult_().GetStatuses(), nil
-	} else {
-		return nil, errors.New("thrift error: Field in response is nil unexpectedly.")
+	if resp == nil || resp.GetResult_() == nil || resp.GetResult_().GetDrainHostsResult_() == nil {
+		return nil, errors.New("unexpected response from scheduler")
 	}
+
+	return resp.GetResult_().GetDrainHostsResult_().GetStatuses(), nil
 }
 
 func (c *Client) StartMaintenance(hosts ...string) ([]*aurora.HostStatus, error) {
@@ -92,17 +108,19 @@ func (c *Client) StartMaintenance(hosts ...string) ([]*aurora.HostStatus, error)
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.adminClient.StartMaintenance(context.TODO(), hostList)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return nil, errors.Wrap(retryErr, "unable to recover connection")
 	}
 
-	if resp.GetResult_() != nil && resp.GetResult_().GetStartMaintenanceResult_() != nil {
-		return resp.GetResult_().GetStartMaintenanceResult_().GetStatuses(), nil
-	} else {
-		return nil, errors.New("thrift error: Field in response is nil unexpectedly.")
+	if resp == nil || resp.GetResult_() == nil || resp.GetResult_().GetStartMaintenanceResult_() == nil {
+		return nil, errors.New("unexpected response from scheduler")
 	}
+
+	return resp.GetResult_().GetStartMaintenanceResult_().GetStatuses(), nil
 }
 
 func (c *Client) EndMaintenance(hosts ...string) ([]*aurora.HostStatus, error) {
@@ -118,24 +136,20 @@ func (c *Client) EndMaintenance(hosts ...string) ([]*aurora.HostStatus, error) {
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.adminClient.EndMaintenance(context.TODO(), hostList)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return nil, errors.Wrap(retryErr, "unable to recover connection")
 	}
-
-	if resp.GetResult_() != nil && resp.GetResult_().GetEndMaintenanceResult_() != nil {
-		return resp.GetResult_().GetEndMaintenanceResult_().GetStatuses(), nil
-	} else {
-		return nil, errors.New("thrift error: Field in response is nil unexpectedly.")
+	if resp == nil || resp.GetResult_() == nil || resp.GetResult_().GetEndMaintenanceResult_() == nil {
+		return nil, errors.New("unexpected response from scheduler")
 	}
-
+	return resp.GetResult_().GetEndMaintenanceResult_().GetStatuses(), nil
 }
 
 func (c *Client) MaintenanceStatus(hosts ...string) (*aurora.MaintenanceStatusResult_, error) {
-
-	var result *aurora.MaintenanceStatusResult_
-
 	if len(hosts) == 0 {
 		return nil, errors.New("no hosts provided to get maintenance status from")
 	}
@@ -149,17 +163,18 @@ func (c *Client) MaintenanceStatus(hosts ...string) (*aurora.MaintenanceStatusRe
 	// and continue trying to resend command until we run out of retries.
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.adminClient.MaintenanceStatus(context.TODO(), hostList)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
-		return result, errors.Wrap(retryErr, "unable to recover connection")
+		return nil, errors.Wrap(retryErr, "unable to recover connection")
+	}
+	if resp == nil || resp.GetResult_() == nil {
+		return nil, errors.New("unexpected response from scheduler")
 	}
 
-	if resp.GetResult_() != nil {
-		result = resp.GetResult_().GetMaintenanceStatusResult_()
-	}
-
-	return result, nil
+	return resp.GetResult_().GetMaintenanceStatusResult_(), nil
 }
 
 // SetQuota sets a quota aggregate for the given role
@@ -177,7 +192,9 @@ func (c *Client) SetQuota(role string, cpu *float64, ramMb *int64, diskMb *int64
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.adminClient.SetQuota(context.TODO(), role, quota)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "unable to set role quota")
@@ -191,17 +208,18 @@ func (c *Client) GetQuota(role string) (*aurora.GetQuotaResult_, error) {
 
 	resp, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.adminClient.GetQuota(context.TODO(), role)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return nil, errors.Wrap(retryErr, "unable to get role quota")
 	}
 
-	if resp.GetResult_() != nil {
-		return resp.GetResult_().GetGetQuotaResult_(), nil
-	} else {
-		return nil, errors.New("thrift error: Field in response is nil unexpectedly.")
+	if resp == nil || resp.GetResult_() == nil {
+		return nil, errors.New("unexpected response from scheduler")
 	}
+	return resp.GetResult_().GetGetQuotaResult_(), nil
 }
 
 // Force Aurora Scheduler to perform a snapshot and write to Mesos log
@@ -209,7 +227,9 @@ func (c *Client) Snapshot() error {
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.adminClient.Snapshot(context.TODO())
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "unable to recover connection")
@@ -223,7 +243,9 @@ func (c *Client) PerformBackup() error {
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.adminClient.PerformBackup(context.TODO())
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "unable to recover connection")
@@ -237,7 +259,9 @@ func (c *Client) ForceImplicitTaskReconciliation() error {
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.adminClient.TriggerImplicitTaskReconciliation(context.TODO())
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "unable to recover connection")
@@ -258,7 +282,9 @@ func (c *Client) ForceExplicitTaskReconciliation(batchSize *int32) error {
 
 	_, retryErr := c.thriftCallWithRetries(false, func() (*aurora.Response, error) {
 		return c.adminClient.TriggerExplicitTaskReconciliation(context.TODO(), settings)
-	})
+	},
+		nil,
+	)
 
 	if retryErr != nil {
 		return errors.Wrap(retryErr, "unable to recover connection")

realis_config.go

@@ -19,6 +19,7 @@ import (
 	"time"
 
 	"github.com/apache/thrift/lib/go/thrift"
+	"github.com/aurora-scheduler/gorealis/v2/gen-go/apache/aurora"
 )
 
 type clientConfig struct {
@@ -48,6 +49,15 @@ var defaultBackoff = Backoff{
 	Jitter:   0.1,
 }
 
+var defaultSlaPolicy = aurora.SlaPolicy{
+	PercentageSlaPolicy: &aurora.PercentageSlaPolicy{
+		Percentage:   66,
+		DurationSecs: 300,
+	},
+}
+
+const defaultSlaDrainTimeoutSecs = 900
+
 type TransportProtocol int
 
 const (

response/response.go

@@ -35,6 +35,10 @@ func ScheduleStatusResult(resp *aurora.Response) *aurora.ScheduleStatusResult_ {
 }
 
 func JobUpdateSummaries(resp *aurora.Response) []*aurora.JobUpdateSummary {
+	if resp == nil || resp.GetResult_() == nil || resp.GetResult_().GetGetJobUpdateSummariesResult_() == nil {
+		return nil
+	}
+
 	return resp.GetResult_().GetGetJobUpdateSummariesResult_().GetUpdateSummaries()
 }
 

retry.go

@@ -17,10 +17,7 @@ package realis
 import (
 	"io"
 	"math/rand"
-	"net/http"
 	"net/url"
-	"strconv"
-	"strings"
 	"time"
 
 	"github.com/apache/thrift/lib/go/thrift"
@@ -29,9 +26,11 @@ import (
 	"github.com/pkg/errors"
 )
 
+// Backoff determines how the retry mechanism should react after each failure and how many failures it should
+// tolerate.
 type Backoff struct {
 	Duration time.Duration // the base duration
-	Factor   float64       // Duration is multipled by factor each iteration
+	Factor   float64       // Duration is multiplied by a factor each iteration
 	Jitter   float64       // The amount of jitter applied each iteration
 	Steps    int           // Exit with error after this many steps
 }
@@ -53,18 +52,15 @@ func Jitter(duration time.Duration, maxFactor float64) time.Duration {
 // if the loop should be aborted.
 type ConditionFunc func() (done bool, err error)
 
-// Modified version of the Kubernetes exponential-backoff code.
-// ExponentialBackoff repeats a condition check with exponential backoff.
-//
-// It checks the condition up to Steps times, increasing the wait by multiplying
-// the previous duration by Factor.
+// ExponentialBackoff is a modified version of the Kubernetes exponential-backoff code.
+// It repeats a condition check with exponential backoff and checks the condition up to
+// Steps times, increasing the wait by multiplying the previous duration by Factor.
 //
 // If Jitter is greater than zero, a random amount of each duration is added
 // (between duration and duration*(1+jitter)).
 //
 // If the condition never returns true, ErrWaitTimeout is returned. Errors
 // do not cause the function to return.
-
 func ExponentialBackoff(backoff Backoff, logger Logger, condition ConditionFunc) error {
 	var err error
 	var ok bool
@@ -98,10 +94,9 @@ func ExponentialBackoff(backoff Backoff, logger Logger, condition ConditionFunc)
 			// If the error is temporary, continue retrying.
 			if !IsTemporary(err) {
 				return err
-			} else {
-				// Print out the temporary error we experienced.
-				logger.Println(err)
 			}
+			// Print out the temporary error we experienced.
+			logger.Println(err)
 		}
 	}
 
@@ -112,19 +107,28 @@ func ExponentialBackoff(backoff Backoff, logger Logger, condition ConditionFunc)
 	// Provide more information to the user wherever possible
 	if err != nil {
 		return newRetryError(errors.Wrap(err, "ran out of retries"), curStep)
-	} else {
-		return newRetryError(errors.New("ran out of retries"), curStep)
 	}
+
+	return newRetryError(errors.New("ran out of retries"), curStep)
 }
 
 type auroraThriftCall func() (resp *aurora.Response, err error)
 
+// verifyOntimeout defines the type of function that will be used to verify whether a Thirft call to the Scheduler
+// made it to the scheduler or not. In general, these types of functions will have to interact with the scheduler
+// through the very same Thrift API which previously encountered a time-out from the client.
+// This means that the functions themselves should be kept to a minimum number of Thrift calls.
+// It should also be noted that this is a best effort mechanism and
+// is likely to fail for the same reasons that the original call failed.
+type verifyOnTimeout func() (*aurora.Response, bool)
+
 // Duplicates the functionality of ExponentialBackoff but is specifically targeted towards ThriftCalls.
-func (c *Client) thriftCallWithRetries(returnOnTimeout bool, thriftCall auroraThriftCall) (*aurora.Response, error) {
+func (c *Client) thriftCallWithRetries(returnOnTimeout bool, thriftCall auroraThriftCall,
+	verifyOnTimeout verifyOnTimeout) (*aurora.Response, error) {
 	var resp *aurora.Response
 	var clientErr error
 	var curStep int
-	var timeouts int
+	timeouts := 0
 
 	backoff := c.config.backoff
 	duration := backoff.Duration
@@ -138,7 +142,10 @@ func (c *Client) thriftCallWithRetries(returnOnTimeout bool, thriftCall auroraTh
 				adjusted = Jitter(duration, backoff.Jitter)
 			}
 
-			c.logger.Printf("A retryable error occurred during thrift call, backing off for %v before retry %v\n", adjusted, curStep)
+			c.logger.Printf(
+				"A retryable error occurred during thrift call, backing off for %v before retry %v",
+				adjusted,
+				curStep)
 
 			time.Sleep(adjusted)
 			duration = time.Duration(float64(duration) * backoff.Factor)
@@ -153,105 +160,132 @@ func (c *Client) thriftCallWithRetries(returnOnTimeout bool, thriftCall auroraTh
 
 			resp, clientErr = thriftCall()
 
-			c.logger.TracePrintf("Aurora Thrift Call ended resp: %v clientErr: %v\n", resp, clientErr)
+			c.logger.TracePrintf("Aurora Thrift Call ended resp: %v clientErr: %v", resp, clientErr)
 		}()
 
 		// Check if our thrift call is returning an error. This is a retryable event as we don't know
 		// if it was caused by network issues.
 		if clientErr != nil {
-
 			// Print out the error to the user
-			c.logger.Printf("Client Error: %v\n", clientErr)
+			c.logger.Printf("Client Error: %v", clientErr)
 
-			// Determine if error is a temporary URL error by going up the stack
-			e, ok := clientErr.(thrift.TTransportException)
-			if ok {
-				c.logger.DebugPrint("Encountered a transport exception")
+			temporary, timedout := isConnectionError(clientErr)
+			if !temporary && c.RealisConfig().failOnPermanentErrors {
+				return nil, errors.Wrap(clientErr, "permanent connection error")
+			}
 
-				// TODO(rdelvalle): Figure out a better way to obtain the error code as this is a very brittle solution
-				// 401 Unauthorized means the wrong username and password were provided
-				if strings.Contains(e.Error(), strconv.Itoa(http.StatusUnauthorized)) {
-					return nil, errors.Wrap(clientErr, "wrong username or password provided")
-				}
-
-				e, ok := e.Err().(*url.Error)
-				if ok {
-					// EOF error occurs when the server closes the read buffer of the client. This is common
-					// when the server is overloaded and should be retried. All other errors that are permanent
-					// will not be retried.
-					if e.Err != io.EOF && !e.Temporary() && c.RealisConfig().failOnPermanentErrors {
-						return nil, errors.Wrap(clientErr, "permanent connection error")
-					}
-					// Corner case where thrift payload was received by Aurora but connection timedout before Aurora was
-					// able to reply. In this case we will return whatever response was received and a TimedOut behaving
-					// error. Users can take special action on a timeout by using IsTimedout and reacting accordingly.
-					if e.Timeout() {
-						timeouts++
-						c.logger.DebugPrintf(
-							"Client closed connection (timedout) %d times before server responded,"+
-								" consider increasing connection timeout",
-							timeouts)
-						if returnOnTimeout {
-							return resp,
-								newTimedoutError(errors.New("client connection closed before server answer"))
-						}
-					}
-				}
+			// There exists a corner case where thrift payload was received by Aurora but
+			// connection timed out before Aurora was able to reply.
+			// Users can take special action on a timeout by using IsTimedout and reacting accordingly
+			// if they have configured the client to return on a timeout.
+			if timedout && returnOnTimeout {
+				return resp, newTimedoutError(errors.New("client connection closed before server answer"))
 			}
 
 			// In the future, reestablish connection should be able to check if it is actually possible
 			// to make a thrift call to Aurora. For now, a reconnect should always lead to a retry.
 			// Ignoring error due to the fact that an error should be retried regardless
-			_ = c.ReestablishConn()
-
-		} else {
-
-			// If there was no client error, but the response is nil, something went wrong.
-			// Ideally, we'll never encounter this but we're placing a safeguard here.
-			if resp == nil {
-				return nil, errors.New("response from aurora is nil")
+			reestablishErr := c.ReestablishConn()
+			if reestablishErr != nil {
+				c.logger.DebugPrintf("error re-establishing connection ", reestablishErr)
 			}
 
-			// Check Response Code from thrift and make a decision to continue retrying or not.
-			switch responseCode := resp.GetResponseCode(); responseCode {
+			// If users did not opt for a return on timeout in order to react to a timedout error,
+			// attempt to verify that the call made it to the scheduler after the connection was re-established.
+			if timedout {
+				timeouts++
+				c.logger.DebugPrintf(
+					"Client closed connection %d times before server responded, "+
+						"consider increasing connection timeout",
+					timeouts)
 
-			// If the thrift call succeeded, stop retrying
-			case aurora.ResponseCode_OK:
-				return resp, nil
-
-			// If the response code is transient, continue retrying
-			case aurora.ResponseCode_ERROR_TRANSIENT:
-				c.logger.Println("Aurora replied with Transient error code, retrying")
-				continue
-
-			// Failure scenarios, these indicate a bad payload or a bad clientConfig. Stop retrying.
-			case aurora.ResponseCode_INVALID_REQUEST,
-				aurora.ResponseCode_ERROR,
-				aurora.ResponseCode_AUTH_FAILED,
-				aurora.ResponseCode_JOB_UPDATING_ERROR:
-				c.logger.Printf("Terminal Response Code %v from Aurora, won't retry\n", resp.GetResponseCode().String())
-				return resp, errors.New(response.CombineMessage(resp))
-
-				// The only case that should fall down to here is a WARNING response code.
-				// It is currently not used as a response in the scheduler so it is unknown how to handle it.
-			default:
-				c.logger.DebugPrintf("unhandled response code %v received from Aurora\n", responseCode)
-				return nil, errors.Errorf("unhandled response code from Aurora %v", responseCode.String())
+				// Allow caller to provide a function which checks if the original call was successful before
+				// it timed out.
+				if verifyOnTimeout != nil {
+					if verifyResp, ok := verifyOnTimeout(); ok {
+						c.logger.Print("verified that the call went through successfully after a client timeout")
+						// Response here might be different than the original as it is no longer constructed
+						// by the scheduler but mimicked.
+						// This is OK since the scheduler is very unlikely to change responses at this point in its
+						// development cycle but we must be careful to not return an incorrectly constructed response.
+						return verifyResp, nil
+					}
+				}
 			}
+
+			// Retry the thrift payload
+			continue
 		}
 
+		// If there was no client error, but the response is nil, something went wrong.
+		// Ideally, we'll never encounter this but we're placing a safeguard here.
+		if resp == nil {
+			return nil, errors.New("response from aurora is nil")
+		}
+
+		// Check Response Code from thrift and make a decision to continue retrying or not.
+		switch responseCode := resp.GetResponseCode(); responseCode {
+
+		// If the thrift call succeeded, stop retrying
+		case aurora.ResponseCode_OK:
+			return resp, nil
+
+		// If the response code is transient, continue retrying
+		case aurora.ResponseCode_ERROR_TRANSIENT:
+			c.logger.Println("Aurora replied with Transient error code, retrying")
+			continue
+
+		// Failure scenarios, these indicate a bad payload or a bad clientConfig. Stop retrying.
+		case aurora.ResponseCode_INVALID_REQUEST,
+			aurora.ResponseCode_ERROR,
+			aurora.ResponseCode_AUTH_FAILED,
+			aurora.ResponseCode_JOB_UPDATING_ERROR:
+			c.logger.Printf("Terminal Response Code %v from Aurora, won't retry\n", resp.GetResponseCode().String())
+			return resp, errors.New(response.CombineMessage(resp))
+
+			// The only case that should fall down to here is a WARNING response code.
+			// It is currently not used as a response in the scheduler so it is unknown how to handle it.
+		default:
+			c.logger.DebugPrintf("unhandled response code %v received from Aurora\n", responseCode)
+			return nil, errors.Errorf("unhandled response code from Aurora %v", responseCode.String())
+		}
 	}
 
-	c.logger.DebugPrintf("it took %v retries to complete this operation\n", curStep)
-
 	if curStep > 1 {
-		c.config.logger.Printf("retried this thrift call %d time(s)", curStep)
+		c.config.logger.Printf("this thrift call was retried %d time(s)", curStep)
 	}
 
 	// Provide more information to the user wherever possible.
 	if clientErr != nil {
 		return nil, newRetryError(errors.Wrap(clientErr, "ran out of retries, including latest error"), curStep)
-	} else {
-		return nil, newRetryError(errors.New("ran out of retries"), curStep)
 	}
+
+	return nil, newRetryError(errors.New("ran out of retries"), curStep)
+}
+
+// isConnectionError processes the error received by the client.
+// The return values indicate whether this was determined to be a temporary error
+// and whether it was determined to be a timeout error
+func isConnectionError(err error) (bool, bool) {
+
+	// Determine if error is a temporary URL error by going up the stack
+	transportException, ok := err.(thrift.TTransportException)
+	if !ok {
+		return false, false
+	}
+
+	urlError, ok := transportException.Err().(*url.Error)
+	if !ok {
+		return false, false
+	}
+
+	// EOF error occurs when the server closes the read buffer of the client. This is common
+	// when the server is overloaded and we consider it temporary.
+	// All other which are not temporary as per the member function Temporary(),
+	// are considered not temporary (permanent).
+	if urlError.Err != io.EOF && !urlError.Temporary() {
+		return false, false
+	}
+
+	return true, urlError.Timeout()
 }

runTestsMac.sh

@@ -1,4 +1,4 @@
 #!/bin/bash
 
 # Since we run our docker compose setup in bridge mode to be able to run on MacOS, we have to launch a Docker container within the bridge network in order to avoid any routing issues.
-docker run --rm -t -v $(pwd):/go/src/github.com/aurora-scheduler/gorealis --network gorealis_aurora_cluster golang:1.13-stretch go test -v github.com/aurora-scheduler/gorealis $@
+docker run --rm -t -w /gorealis  -v $GOPATH/pkg:/go/pkg -v $(pwd):/gorealis --network gorealis_aurora_cluster golang:1.17-buster go test -v github.com/aurora-scheduler/gorealis/v2 $@

task.go

@@ -78,12 +78,17 @@ func TaskFromThrift(config *aurora.TaskConfig) *AuroraTask {
 		Role(config.Job.Role).
 		Name(config.Job.Name).
 		MaxFailure(config.MaxTaskFailures).
-		IsService(config.IsService)
+		IsService(config.IsService).
+		Priority(config.Priority)
 
 	if config.Tier != nil {
 		newTask.Tier(*config.Tier)
 	}
 
+	if config.Production != nil {
+		newTask.Production(*config.Production)
+	}
+
 	if config.ExecutorConfig != nil {
 		newTask.
 			ExecutorName(config.ExecutorConfig.Name).
@@ -287,6 +292,17 @@ func (t *AuroraTask) IsService(isService bool) *AuroraTask {
 	return t
 }
 
+//set priority for preemption or priority-queueing
+func (t *AuroraTask) Priority(priority int32) *AuroraTask {
+	t.task.Priority = priority
+	return t
+}
+
+func (t *AuroraTask) Production(production bool) *AuroraTask {
+	t.task.Production = &production
+	return t
+}
+
 // Add a list of URIs with the same extract and cache configuration. Scheduler must have
 // --enable_mesos_fetcher flag enabled. Currently there is no duplicate detection.
 func (t *AuroraTask) AddURIs(extract bool, cache bool, values ...string) *AuroraTask {

task_test.go

@@ -34,6 +34,8 @@ func TestAuroraTask_Clone(t *testing.T) {
 		RAM(643).
 		Disk(1000).
 		IsService(true).
+		Priority(1).
+		Production(false).
 		AddPorts(10).
 		Tier("preferred").
 		MaxFailure(23).

util.go

@@ -40,6 +40,18 @@ func init() {
 	}
 }
 
+// TerminalUpdateStates returns a slice containing all the terminal states an update may be in.
+// This is a function in order to avoid having a slice that can be accidentally mutated.
+func TerminalUpdateStates() []aurora.JobUpdateStatus {
+	return []aurora.JobUpdateStatus{
+		aurora.JobUpdateStatus_ROLLED_FORWARD,
+		aurora.JobUpdateStatus_ROLLED_BACK,
+		aurora.JobUpdateStatus_ABORTED,
+		aurora.JobUpdateStatus_ERROR,
+		aurora.JobUpdateStatus_FAILED,
+	}
+}
+
 func validateAuroraAddress(address string) (string, error) {
 
 	// If no protocol defined, assume http
@@ -73,3 +85,42 @@ func validateAuroraAddress(address string) (string, error) {
 
 	return u.String(), nil
 }
+
+func calculateCurrentBatch(updatingInstances int32, batchSizes []int32) int {
+	for i, size := range batchSizes {
+		updatingInstances -= size
+		if updatingInstances <= 0 {
+			return i
+		}
+	}
+
+	// Overflow batches
+	batchCount := len(batchSizes) - 1
+	lastBatchIndex := len(batchSizes) - 1
+	batchCount += int(updatingInstances / batchSizes[lastBatchIndex])
+
+	if updatingInstances%batchSizes[lastBatchIndex] != 0 {
+		batchCount++
+	}
+	return batchCount
+}
+
+func ResourcesToMap(resources []*aurora.Resource) map[string]float64 {
+	result := map[string]float64{}
+
+	for _, resource := range resources {
+		if resource.NumCpus != nil {
+			result["cpus"] += *resource.NumCpus
+		} else if resource.RamMb != nil {
+			result["mem"] += float64(*resource.RamMb)
+		} else if resource.DiskMb != nil {
+			result["disk"] += float64(*resource.DiskMb)
+		} else if resource.NamedPort != nil {
+			result["ports"]++
+		} else if resource.NumGpus != nil {
+			result["gpus"] += float64(*resource.NumGpus)
+		}
+	}
+
+	return result
+}

util_test.go

@@ -0,0 +1,58 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package realis
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCurrentBatchCalculator(t *testing.T) {
+	t.Run("singleBatchOverflow", func(t *testing.T) {
+		curBatch := calculateCurrentBatch(10, []int32{2})
+		assert.Equal(t, 4, curBatch)
+	})
+
+	t.Run("noInstancesUpdating", func(t *testing.T) {
+		curBatch := calculateCurrentBatch(0, []int32{2})
+		assert.Equal(t, 0, curBatch)
+	})
+
+	t.Run("evenMatchSingleBatch", func(t *testing.T) {
+		curBatch := calculateCurrentBatch(2, []int32{2})
+		assert.Equal(t, 0, curBatch)
+	})
+
+	t.Run("moreInstancesThanBatches", func(t *testing.T) {
+		curBatch := calculateCurrentBatch(5, []int32{1, 2})
+		assert.Equal(t, 2, curBatch)
+	})
+
+	t.Run("moreInstancesThanBatchesDecreasing", func(t *testing.T) {
+		curBatch := calculateCurrentBatch(5, []int32{2, 1})
+		assert.Equal(t, 3, curBatch)
+	})
+
+	t.Run("unevenFit", func(t *testing.T) {
+		curBatch := calculateCurrentBatch(2, []int32{1, 2})
+		assert.Equal(t, 1, curBatch)
+	})
+
+	t.Run("halfWay", func(t *testing.T) {
+		curBatch := calculateCurrentBatch(1, []int32{1, 2})
+		assert.Equal(t, 0, curBatch)
+	})
+}

vendor/github.com/apache/thrift/lib/go/thrift/application_exception.go

@@ -1,164 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-const (
-	UNKNOWN_APPLICATION_EXCEPTION  = 0
-	UNKNOWN_METHOD                 = 1
-	INVALID_MESSAGE_TYPE_EXCEPTION = 2
-	WRONG_METHOD_NAME              = 3
-	BAD_SEQUENCE_ID                = 4
-	MISSING_RESULT                 = 5
-	INTERNAL_ERROR                 = 6
-	PROTOCOL_ERROR                 = 7
-)
-
-var defaultApplicationExceptionMessage = map[int32]string{
-	UNKNOWN_APPLICATION_EXCEPTION:  "unknown application exception",
-	UNKNOWN_METHOD:                 "unknown method",
-	INVALID_MESSAGE_TYPE_EXCEPTION: "invalid message type",
-	WRONG_METHOD_NAME:              "wrong method name",
-	BAD_SEQUENCE_ID:                "bad sequence ID",
-	MISSING_RESULT:                 "missing result",
-	INTERNAL_ERROR:                 "unknown internal error",
-	PROTOCOL_ERROR:                 "unknown protocol error",
-}
-
-// Application level Thrift exception
-type TApplicationException interface {
-	TException
-	TypeId() int32
-	Read(iprot TProtocol) error
-	Write(oprot TProtocol) error
-}
-
-type tApplicationException struct {
-	message string
-	type_   int32
-}
-
-func (e tApplicationException) Error() string {
-	if e.message != "" {
-		return e.message
-	}
-	return defaultApplicationExceptionMessage[e.type_]
-}
-
-func NewTApplicationException(type_ int32, message string) TApplicationException {
-	return &tApplicationException{message, type_}
-}
-
-func (p *tApplicationException) TypeId() int32 {
-	return p.type_
-}
-
-func (p *tApplicationException) Read(iprot TProtocol) error {
-	// TODO: this should really be generated by the compiler
-	_, err := iprot.ReadStructBegin()
-	if err != nil {
-		return err
-	}
-
-	message := ""
-	type_ := int32(UNKNOWN_APPLICATION_EXCEPTION)
-
-	for {
-		_, ttype, id, err := iprot.ReadFieldBegin()
-		if err != nil {
-			return err
-		}
-		if ttype == STOP {
-			break
-		}
-		switch id {
-		case 1:
-			if ttype == STRING {
-				if message, err = iprot.ReadString(); err != nil {
-					return err
-				}
-			} else {
-				if err = SkipDefaultDepth(iprot, ttype); err != nil {
-					return err
-				}
-			}
-		case 2:
-			if ttype == I32 {
-				if type_, err = iprot.ReadI32(); err != nil {
-					return err
-				}
-			} else {
-				if err = SkipDefaultDepth(iprot, ttype); err != nil {
-					return err
-				}
-			}
-		default:
-			if err = SkipDefaultDepth(iprot, ttype); err != nil {
-				return err
-			}
-		}
-		if err = iprot.ReadFieldEnd(); err != nil {
-			return err
-		}
-	}
-	if err := iprot.ReadStructEnd(); err != nil {
-		return err
-	}
-
-	p.message = message
-	p.type_ = type_
-
-	return nil
-}
-
-func (p *tApplicationException) Write(oprot TProtocol) (err error) {
-	err = oprot.WriteStructBegin("TApplicationException")
-	if len(p.Error()) > 0 {
-		err = oprot.WriteFieldBegin("message", STRING, 1)
-		if err != nil {
-			return
-		}
-		err = oprot.WriteString(p.Error())
-		if err != nil {
-			return
-		}
-		err = oprot.WriteFieldEnd()
-		if err != nil {
-			return
-		}
-	}
-	err = oprot.WriteFieldBegin("type", I32, 2)
-	if err != nil {
-		return
-	}
-	err = oprot.WriteI32(p.type_)
-	if err != nil {
-		return
-	}
-	err = oprot.WriteFieldEnd()
-	if err != nil {
-		return
-	}
-	err = oprot.WriteFieldStop()
-	if err != nil {
-		return
-	}
-	err = oprot.WriteStructEnd()
-	return
-}

vendor/github.com/apache/thrift/lib/go/thrift/application_exception_test.go

@@ -1,41 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"testing"
-)
-
-func TestTApplicationException(t *testing.T) {
-	exc := NewTApplicationException(UNKNOWN_APPLICATION_EXCEPTION, "")
-	if exc.Error() != defaultApplicationExceptionMessage[UNKNOWN_APPLICATION_EXCEPTION] {
-		t.Fatalf("Expected empty string for exception but found '%s'", exc.Error())
-	}
-	if exc.TypeId() != UNKNOWN_APPLICATION_EXCEPTION {
-		t.Fatalf("Expected type UNKNOWN for exception but found '%v'", exc.TypeId())
-	}
-	exc = NewTApplicationException(WRONG_METHOD_NAME, "junk_method")
-	if exc.Error() != "junk_method" {
-		t.Fatalf("Expected 'junk_method' for exception but found '%s'", exc.Error())
-	}
-	if exc.TypeId() != WRONG_METHOD_NAME {
-		t.Fatalf("Expected type WRONG_METHOD_NAME for exception but found '%v'", exc.TypeId())
-	}
-}

vendor/github.com/apache/thrift/lib/go/thrift/binary_protocol.go

@@ -1,509 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"bytes"
-	"context"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-)
-
-type TBinaryProtocol struct {
-	trans         TRichTransport
-	origTransport TTransport
-	reader        io.Reader
-	writer        io.Writer
-	strictRead    bool
-	strictWrite   bool
-	buffer        [64]byte
-}
-
-type TBinaryProtocolFactory struct {
-	strictRead  bool
-	strictWrite bool
-}
-
-func NewTBinaryProtocolTransport(t TTransport) *TBinaryProtocol {
-	return NewTBinaryProtocol(t, false, true)
-}
-
-func NewTBinaryProtocol(t TTransport, strictRead, strictWrite bool) *TBinaryProtocol {
-	p := &TBinaryProtocol{origTransport: t, strictRead: strictRead, strictWrite: strictWrite}
-	if et, ok := t.(TRichTransport); ok {
-		p.trans = et
-	} else {
-		p.trans = NewTRichTransport(t)
-	}
-	p.reader = p.trans
-	p.writer = p.trans
-	return p
-}
-
-func NewTBinaryProtocolFactoryDefault() *TBinaryProtocolFactory {
-	return NewTBinaryProtocolFactory(false, true)
-}
-
-func NewTBinaryProtocolFactory(strictRead, strictWrite bool) *TBinaryProtocolFactory {
-	return &TBinaryProtocolFactory{strictRead: strictRead, strictWrite: strictWrite}
-}
-
-func (p *TBinaryProtocolFactory) GetProtocol(t TTransport) TProtocol {
-	return NewTBinaryProtocol(t, p.strictRead, p.strictWrite)
-}
-
-/**
- * Writing Methods
- */
-
-func (p *TBinaryProtocol) WriteMessageBegin(name string, typeId TMessageType, seqId int32) error {
-	if p.strictWrite {
-		version := uint32(VERSION_1) | uint32(typeId)
-		e := p.WriteI32(int32(version))
-		if e != nil {
-			return e
-		}
-		e = p.WriteString(name)
-		if e != nil {
-			return e
-		}
-		e = p.WriteI32(seqId)
-		return e
-	} else {
-		e := p.WriteString(name)
-		if e != nil {
-			return e
-		}
-		e = p.WriteByte(int8(typeId))
-		if e != nil {
-			return e
-		}
-		e = p.WriteI32(seqId)
-		return e
-	}
-	return nil
-}
-
-func (p *TBinaryProtocol) WriteMessageEnd() error {
-	return nil
-}
-
-func (p *TBinaryProtocol) WriteStructBegin(name string) error {
-	return nil
-}
-
-func (p *TBinaryProtocol) WriteStructEnd() error {
-	return nil
-}
-
-func (p *TBinaryProtocol) WriteFieldBegin(name string, typeId TType, id int16) error {
-	e := p.WriteByte(int8(typeId))
-	if e != nil {
-		return e
-	}
-	e = p.WriteI16(id)
-	return e
-}
-
-func (p *TBinaryProtocol) WriteFieldEnd() error {
-	return nil
-}
-
-func (p *TBinaryProtocol) WriteFieldStop() error {
-	e := p.WriteByte(STOP)
-	return e
-}
-
-func (p *TBinaryProtocol) WriteMapBegin(keyType TType, valueType TType, size int) error {
-	e := p.WriteByte(int8(keyType))
-	if e != nil {
-		return e
-	}
-	e = p.WriteByte(int8(valueType))
-	if e != nil {
-		return e
-	}
-	e = p.WriteI32(int32(size))
-	return e
-}
-
-func (p *TBinaryProtocol) WriteMapEnd() error {
-	return nil
-}
-
-func (p *TBinaryProtocol) WriteListBegin(elemType TType, size int) error {
-	e := p.WriteByte(int8(elemType))
-	if e != nil {
-		return e
-	}
-	e = p.WriteI32(int32(size))
-	return e
-}
-
-func (p *TBinaryProtocol) WriteListEnd() error {
-	return nil
-}
-
-func (p *TBinaryProtocol) WriteSetBegin(elemType TType, size int) error {
-	e := p.WriteByte(int8(elemType))
-	if e != nil {
-		return e
-	}
-	e = p.WriteI32(int32(size))
-	return e
-}
-
-func (p *TBinaryProtocol) WriteSetEnd() error {
-	return nil
-}
-
-func (p *TBinaryProtocol) WriteBool(value bool) error {
-	if value {
-		return p.WriteByte(1)
-	}
-	return p.WriteByte(0)
-}
-
-func (p *TBinaryProtocol) WriteByte(value int8) error {
-	e := p.trans.WriteByte(byte(value))
-	return NewTProtocolException(e)
-}
-
-func (p *TBinaryProtocol) WriteI16(value int16) error {
-	v := p.buffer[0:2]
-	binary.BigEndian.PutUint16(v, uint16(value))
-	_, e := p.writer.Write(v)
-	return NewTProtocolException(e)
-}
-
-func (p *TBinaryProtocol) WriteI32(value int32) error {
-	v := p.buffer[0:4]
-	binary.BigEndian.PutUint32(v, uint32(value))
-	_, e := p.writer.Write(v)
-	return NewTProtocolException(e)
-}
-
-func (p *TBinaryProtocol) WriteI64(value int64) error {
-	v := p.buffer[0:8]
-	binary.BigEndian.PutUint64(v, uint64(value))
-	_, err := p.writer.Write(v)
-	return NewTProtocolException(err)
-}
-
-func (p *TBinaryProtocol) WriteDouble(value float64) error {
-	return p.WriteI64(int64(math.Float64bits(value)))
-}
-
-func (p *TBinaryProtocol) WriteString(value string) error {
-	e := p.WriteI32(int32(len(value)))
-	if e != nil {
-		return e
-	}
-	_, err := p.trans.WriteString(value)
-	return NewTProtocolException(err)
-}
-
-func (p *TBinaryProtocol) WriteBinary(value []byte) error {
-	e := p.WriteI32(int32(len(value)))
-	if e != nil {
-		return e
-	}
-	_, err := p.writer.Write(value)
-	return NewTProtocolException(err)
-}
-
-/**
- * Reading methods
- */
-
-func (p *TBinaryProtocol) ReadMessageBegin() (name string, typeId TMessageType, seqId int32, err error) {
-	size, e := p.ReadI32()
-	if e != nil {
-		return "", typeId, 0, NewTProtocolException(e)
-	}
-	if size < 0 {
-		typeId = TMessageType(size & 0x0ff)
-		version := int64(int64(size) & VERSION_MASK)
-		if version != VERSION_1 {
-			return name, typeId, seqId, NewTProtocolExceptionWithType(BAD_VERSION, fmt.Errorf("Bad version in ReadMessageBegin"))
-		}
-		name, e = p.ReadString()
-		if e != nil {
-			return name, typeId, seqId, NewTProtocolException(e)
-		}
-		seqId, e = p.ReadI32()
-		if e != nil {
-			return name, typeId, seqId, NewTProtocolException(e)
-		}
-		return name, typeId, seqId, nil
-	}
-	if p.strictRead {
-		return name, typeId, seqId, NewTProtocolExceptionWithType(BAD_VERSION, fmt.Errorf("Missing version in ReadMessageBegin"))
-	}
-	name, e2 := p.readStringBody(size)
-	if e2 != nil {
-		return name, typeId, seqId, e2
-	}
-	b, e3 := p.ReadByte()
-	if e3 != nil {
-		return name, typeId, seqId, e3
-	}
-	typeId = TMessageType(b)
-	seqId, e4 := p.ReadI32()
-	if e4 != nil {
-		return name, typeId, seqId, e4
-	}
-	return name, typeId, seqId, nil
-}
-
-func (p *TBinaryProtocol) ReadMessageEnd() error {
-	return nil
-}
-
-func (p *TBinaryProtocol) ReadStructBegin() (name string, err error) {
-	return
-}
-
-func (p *TBinaryProtocol) ReadStructEnd() error {
-	return nil
-}
-
-func (p *TBinaryProtocol) ReadFieldBegin() (name string, typeId TType, seqId int16, err error) {
-	t, err := p.ReadByte()
-	typeId = TType(t)
-	if err != nil {
-		return name, typeId, seqId, err
-	}
-	if t != STOP {
-		seqId, err = p.ReadI16()
-	}
-	return name, typeId, seqId, err
-}
-
-func (p *TBinaryProtocol) ReadFieldEnd() error {
-	return nil
-}
-
-var invalidDataLength = NewTProtocolExceptionWithType(INVALID_DATA, errors.New("Invalid data length"))
-
-func (p *TBinaryProtocol) ReadMapBegin() (kType, vType TType, size int, err error) {
-	k, e := p.ReadByte()
-	if e != nil {
-		err = NewTProtocolException(e)
-		return
-	}
-	kType = TType(k)
-	v, e := p.ReadByte()
-	if e != nil {
-		err = NewTProtocolException(e)
-		return
-	}
-	vType = TType(v)
-	size32, e := p.ReadI32()
-	if e != nil {
-		err = NewTProtocolException(e)
-		return
-	}
-	if size32 < 0 {
-		err = invalidDataLength
-		return
-	}
-	size = int(size32)
-	return kType, vType, size, nil
-}
-
-func (p *TBinaryProtocol) ReadMapEnd() error {
-	return nil
-}
-
-func (p *TBinaryProtocol) ReadListBegin() (elemType TType, size int, err error) {
-	b, e := p.ReadByte()
-	if e != nil {
-		err = NewTProtocolException(e)
-		return
-	}
-	elemType = TType(b)
-	size32, e := p.ReadI32()
-	if e != nil {
-		err = NewTProtocolException(e)
-		return
-	}
-	if size32 < 0 {
-		err = invalidDataLength
-		return
-	}
-	size = int(size32)
-
-	return
-}
-
-func (p *TBinaryProtocol) ReadListEnd() error {
-	return nil
-}
-
-func (p *TBinaryProtocol) ReadSetBegin() (elemType TType, size int, err error) {
-	b, e := p.ReadByte()
-	if e != nil {
-		err = NewTProtocolException(e)
-		return
-	}
-	elemType = TType(b)
-	size32, e := p.ReadI32()
-	if e != nil {
-		err = NewTProtocolException(e)
-		return
-	}
-	if size32 < 0 {
-		err = invalidDataLength
-		return
-	}
-	size = int(size32)
-	return elemType, size, nil
-}
-
-func (p *TBinaryProtocol) ReadSetEnd() error {
-	return nil
-}
-
-func (p *TBinaryProtocol) ReadBool() (bool, error) {
-	b, e := p.ReadByte()
-	v := true
-	if b != 1 {
-		v = false
-	}
-	return v, e
-}
-
-func (p *TBinaryProtocol) ReadByte() (int8, error) {
-	v, err := p.trans.ReadByte()
-	return int8(v), err
-}
-
-func (p *TBinaryProtocol) ReadI16() (value int16, err error) {
-	buf := p.buffer[0:2]
-	err = p.readAll(buf)
-	value = int16(binary.BigEndian.Uint16(buf))
-	return value, err
-}
-
-func (p *TBinaryProtocol) ReadI32() (value int32, err error) {
-	buf := p.buffer[0:4]
-	err = p.readAll(buf)
-	value = int32(binary.BigEndian.Uint32(buf))
-	return value, err
-}
-
-func (p *TBinaryProtocol) ReadI64() (value int64, err error) {
-	buf := p.buffer[0:8]
-	err = p.readAll(buf)
-	value = int64(binary.BigEndian.Uint64(buf))
-	return value, err
-}
-
-func (p *TBinaryProtocol) ReadDouble() (value float64, err error) {
-	buf := p.buffer[0:8]
-	err = p.readAll(buf)
-	value = math.Float64frombits(binary.BigEndian.Uint64(buf))
-	return value, err
-}
-
-func (p *TBinaryProtocol) ReadString() (value string, err error) {
-	size, e := p.ReadI32()
-	if e != nil {
-		return "", e
-	}
-	if size < 0 {
-		err = invalidDataLength
-		return
-	}
-
-	return p.readStringBody(size)
-}
-
-func (p *TBinaryProtocol) ReadBinary() ([]byte, error) {
-	size, e := p.ReadI32()
-	if e != nil {
-		return nil, e
-	}
-	if size < 0 {
-		return nil, invalidDataLength
-	}
-
-	isize := int(size)
-	buf := make([]byte, isize)
-	_, err := io.ReadFull(p.trans, buf)
-	return buf, NewTProtocolException(err)
-}
-
-func (p *TBinaryProtocol) Flush(ctx context.Context) (err error) {
-	return NewTProtocolException(p.trans.Flush(ctx))
-}
-
-func (p *TBinaryProtocol) Skip(fieldType TType) (err error) {
-	return SkipDefaultDepth(p, fieldType)
-}
-
-func (p *TBinaryProtocol) Transport() TTransport {
-	return p.origTransport
-}
-
-func (p *TBinaryProtocol) readAll(buf []byte) error {
-	_, err := io.ReadFull(p.reader, buf)
-	return NewTProtocolException(err)
-}
-
-const readLimit = 32768
-
-func (p *TBinaryProtocol) readStringBody(size int32) (value string, err error) {
-	if size < 0 {
-		return "", nil
-	}
-
-	var (
-		buf bytes.Buffer
-		e   error
-		b   []byte
-	)
-
-	switch {
-	case int(size) <= len(p.buffer):
-		b = p.buffer[:size] // avoids allocation for small reads
-	case int(size) < readLimit:
-		b = make([]byte, size)
-	default:
-		b = make([]byte, readLimit)
-	}
-
-	for size > 0 {
-		_, e = io.ReadFull(p.trans, b)
-		buf.Write(b)
-		if e != nil {
-			break
-		}
-		size -= readLimit
-		if size < readLimit && size > 0 {
-			b = b[:size]
-		}
-	}
-	return buf.String(), NewTProtocolException(e)
-}

vendor/github.com/apache/thrift/lib/go/thrift/binary_protocol_test.go

@@ -1,28 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"testing"
-)
-
-func TestReadWriteBinaryProtocol(t *testing.T) {
-	ReadWriteProtocolTest(t, NewTBinaryProtocolFactoryDefault())
-}

vendor/github.com/apache/thrift/lib/go/thrift/buffered_transport.go

@@ -1,92 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"bufio"
-	"context"
-)
-
-type TBufferedTransportFactory struct {
-	size int
-}
-
-type TBufferedTransport struct {
-	bufio.ReadWriter
-	tp TTransport
-}
-
-func (p *TBufferedTransportFactory) GetTransport(trans TTransport) (TTransport, error) {
-	return NewTBufferedTransport(trans, p.size), nil
-}
-
-func NewTBufferedTransportFactory(bufferSize int) *TBufferedTransportFactory {
-	return &TBufferedTransportFactory{size: bufferSize}
-}
-
-func NewTBufferedTransport(trans TTransport, bufferSize int) *TBufferedTransport {
-	return &TBufferedTransport{
-		ReadWriter: bufio.ReadWriter{
-			Reader: bufio.NewReaderSize(trans, bufferSize),
-			Writer: bufio.NewWriterSize(trans, bufferSize),
-		},
-		tp: trans,
-	}
-}
-
-func (p *TBufferedTransport) IsOpen() bool {
-	return p.tp.IsOpen()
-}
-
-func (p *TBufferedTransport) Open() (err error) {
-	return p.tp.Open()
-}
-
-func (p *TBufferedTransport) Close() (err error) {
-	return p.tp.Close()
-}
-
-func (p *TBufferedTransport) Read(b []byte) (int, error) {
-	n, err := p.ReadWriter.Read(b)
-	if err != nil {
-		p.ReadWriter.Reader.Reset(p.tp)
-	}
-	return n, err
-}
-
-func (p *TBufferedTransport) Write(b []byte) (int, error) {
-	n, err := p.ReadWriter.Write(b)
-	if err != nil {
-		p.ReadWriter.Writer.Reset(p.tp)
-	}
-	return n, err
-}
-
-func (p *TBufferedTransport) Flush(ctx context.Context) error {
-	if err := p.ReadWriter.Flush(); err != nil {
-		p.ReadWriter.Writer.Reset(p.tp)
-		return err
-	}
-	return p.tp.Flush(ctx)
-}
-
-func (p *TBufferedTransport) RemainingBytes() (num_bytes uint64) {
-	return p.tp.RemainingBytes()
-}

vendor/github.com/apache/thrift/lib/go/thrift/buffered_transport_test.go

@@ -1,29 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"testing"
-)
-
-func TestBufferedTransport(t *testing.T) {
-	trans := NewTBufferedTransport(NewTMemoryBuffer(), 10240)
-	TransportTest(t, trans, trans)
-}

vendor/github.com/apache/thrift/lib/go/thrift/client.go

@@ -1,85 +0,0 @@
-package thrift
-
-import (
-	"context"
-	"fmt"
-)
-
-type TClient interface {
-	Call(ctx context.Context, method string, args, result TStruct) error
-}
-
-type TStandardClient struct {
-	seqId        int32
-	iprot, oprot TProtocol
-}
-
-// TStandardClient implements TClient, and uses the standard message format for Thrift.
-// It is not safe for concurrent use.
-func NewTStandardClient(inputProtocol, outputProtocol TProtocol) *TStandardClient {
-	return &TStandardClient{
-		iprot: inputProtocol,
-		oprot: outputProtocol,
-	}
-}
-
-func (p *TStandardClient) Send(ctx context.Context, oprot TProtocol, seqId int32, method string, args TStruct) error {
-	if err := oprot.WriteMessageBegin(method, CALL, seqId); err != nil {
-		return err
-	}
-	if err := args.Write(oprot); err != nil {
-		return err
-	}
-	if err := oprot.WriteMessageEnd(); err != nil {
-		return err
-	}
-	return oprot.Flush(ctx)
-}
-
-func (p *TStandardClient) Recv(iprot TProtocol, seqId int32, method string, result TStruct) error {
-	rMethod, rTypeId, rSeqId, err := iprot.ReadMessageBegin()
-	if err != nil {
-		return err
-	}
-
-	if method != rMethod {
-		return NewTApplicationException(WRONG_METHOD_NAME, fmt.Sprintf("%s: wrong method name", method))
-	} else if seqId != rSeqId {
-		return NewTApplicationException(BAD_SEQUENCE_ID, fmt.Sprintf("%s: out of order sequence response", method))
-	} else if rTypeId == EXCEPTION {
-		var exception tApplicationException
-		if err := exception.Read(iprot); err != nil {
-			return err
-		}
-
-		if err := iprot.ReadMessageEnd(); err != nil {
-			return err
-		}
-
-		return &exception
-	} else if rTypeId != REPLY {
-		return NewTApplicationException(INVALID_MESSAGE_TYPE_EXCEPTION, fmt.Sprintf("%s: invalid message type", method))
-	}
-
-	if err := result.Read(iprot); err != nil {
-		return err
-	}
-
-	return iprot.ReadMessageEnd()
-}
-
-func (p *TStandardClient) Call(ctx context.Context, method string, args, result TStruct) error {
-	p.seqId++
-	seqId := p.seqId
-
-	if err := p.Send(ctx, p.oprot, seqId, method, args); err != nil {
-		return err
-	}
-
-	// method is oneway
-	if result == nil {
-		return nil
-	}
-
-	return p.Recv(p.iprot, seqId, method, result)
-}

vendor/github.com/apache/thrift/lib/go/thrift/common_test.go

@@ -1,30 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import "context"
-
-type mockProcessor struct {
-	ProcessFunc func(in, out TProtocol) (bool, TException)
-}
-
-func (m *mockProcessor) Process(ctx context.Context, in, out TProtocol) (bool, TException) {
-	return m.ProcessFunc(in, out)
-}

vendor/github.com/apache/thrift/lib/go/thrift/compact_protocol.go

@@ -1,810 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"context"
-	"encoding/binary"
-	"fmt"
-	"io"
-	"math"
-)
-
-const (
-	COMPACT_PROTOCOL_ID       = 0x082
-	COMPACT_VERSION           = 1
-	COMPACT_VERSION_MASK      = 0x1f
-	COMPACT_TYPE_MASK         = 0x0E0
-	COMPACT_TYPE_BITS         = 0x07
-	COMPACT_TYPE_SHIFT_AMOUNT = 5
-)
-
-type tCompactType byte
-
-const (
-	COMPACT_BOOLEAN_TRUE  = 0x01
-	COMPACT_BOOLEAN_FALSE = 0x02
-	COMPACT_BYTE          = 0x03
-	COMPACT_I16           = 0x04
-	COMPACT_I32           = 0x05
-	COMPACT_I64           = 0x06
-	COMPACT_DOUBLE        = 0x07
-	COMPACT_BINARY        = 0x08
-	COMPACT_LIST          = 0x09
-	COMPACT_SET           = 0x0A
-	COMPACT_MAP           = 0x0B
-	COMPACT_STRUCT        = 0x0C
-)
-
-var (
-	ttypeToCompactType map[TType]tCompactType
-)
-
-func init() {
-	ttypeToCompactType = map[TType]tCompactType{
-		STOP:   STOP,
-		BOOL:   COMPACT_BOOLEAN_TRUE,
-		BYTE:   COMPACT_BYTE,
-		I16:    COMPACT_I16,
-		I32:    COMPACT_I32,
-		I64:    COMPACT_I64,
-		DOUBLE: COMPACT_DOUBLE,
-		STRING: COMPACT_BINARY,
-		LIST:   COMPACT_LIST,
-		SET:    COMPACT_SET,
-		MAP:    COMPACT_MAP,
-		STRUCT: COMPACT_STRUCT,
-	}
-}
-
-type TCompactProtocolFactory struct{}
-
-func NewTCompactProtocolFactory() *TCompactProtocolFactory {
-	return &TCompactProtocolFactory{}
-}
-
-func (p *TCompactProtocolFactory) GetProtocol(trans TTransport) TProtocol {
-	return NewTCompactProtocol(trans)
-}
-
-type TCompactProtocol struct {
-	trans         TRichTransport
-	origTransport TTransport
-
-	// Used to keep track of the last field for the current and previous structs,
-	// so we can do the delta stuff.
-	lastField   []int
-	lastFieldId int
-
-	// If we encounter a boolean field begin, save the TField here so it can
-	// have the value incorporated.
-	booleanFieldName    string
-	booleanFieldId      int16
-	booleanFieldPending bool
-
-	// If we read a field header, and it's a boolean field, save the boolean
-	// value here so that readBool can use it.
-	boolValue          bool
-	boolValueIsNotNull bool
-	buffer             [64]byte
-}
-
-// Create a TCompactProtocol given a TTransport
-func NewTCompactProtocol(trans TTransport) *TCompactProtocol {
-	p := &TCompactProtocol{origTransport: trans, lastField: []int{}}
-	if et, ok := trans.(TRichTransport); ok {
-		p.trans = et
-	} else {
-		p.trans = NewTRichTransport(trans)
-	}
-
-	return p
-
-}
-
-//
-// Public Writing methods.
-//
-
-// Write a message header to the wire. Compact Protocol messages contain the
-// protocol version so we can migrate forwards in the future if need be.
-func (p *TCompactProtocol) WriteMessageBegin(name string, typeId TMessageType, seqid int32) error {
-	err := p.writeByteDirect(COMPACT_PROTOCOL_ID)
-	if err != nil {
-		return NewTProtocolException(err)
-	}
-	err = p.writeByteDirect((COMPACT_VERSION & COMPACT_VERSION_MASK) | ((byte(typeId) << COMPACT_TYPE_SHIFT_AMOUNT) & COMPACT_TYPE_MASK))
-	if err != nil {
-		return NewTProtocolException(err)
-	}
-	_, err = p.writeVarint32(seqid)
-	if err != nil {
-		return NewTProtocolException(err)
-	}
-	e := p.WriteString(name)
-	return e
-
-}
-
-func (p *TCompactProtocol) WriteMessageEnd() error { return nil }
-
-// Write a struct begin. This doesn't actually put anything on the wire. We
-// use it as an opportunity to put special placeholder markers on the field
-// stack so we can get the field id deltas correct.
-func (p *TCompactProtocol) WriteStructBegin(name string) error {
-	p.lastField = append(p.lastField, p.lastFieldId)
-	p.lastFieldId = 0
-	return nil
-}
-
-// Write a struct end. This doesn't actually put anything on the wire. We use
-// this as an opportunity to pop the last field from the current struct off
-// of the field stack.
-func (p *TCompactProtocol) WriteStructEnd() error {
-	p.lastFieldId = p.lastField[len(p.lastField)-1]
-	p.lastField = p.lastField[:len(p.lastField)-1]
-	return nil
-}
-
-func (p *TCompactProtocol) WriteFieldBegin(name string, typeId TType, id int16) error {
-	if typeId == BOOL {
-		// we want to possibly include the value, so we'll wait.
-		p.booleanFieldName, p.booleanFieldId, p.booleanFieldPending = name, id, true
-		return nil
-	}
-	_, err := p.writeFieldBeginInternal(name, typeId, id, 0xFF)
-	return NewTProtocolException(err)
-}
-
-// The workhorse of writeFieldBegin. It has the option of doing a
-// 'type override' of the type header. This is used specifically in the
-// boolean field case.
-func (p *TCompactProtocol) writeFieldBeginInternal(name string, typeId TType, id int16, typeOverride byte) (int, error) {
-	// short lastField = lastField_.pop();
-
-	// if there's a type override, use that.
-	var typeToWrite byte
-	if typeOverride == 0xFF {
-		typeToWrite = byte(p.getCompactType(typeId))
-	} else {
-		typeToWrite = typeOverride
-	}
-	// check if we can use delta encoding for the field id
-	fieldId := int(id)
-	written := 0
-	if fieldId > p.lastFieldId && fieldId-p.lastFieldId <= 15 {
-		// write them together
-		err := p.writeByteDirect(byte((fieldId-p.lastFieldId)<<4) | typeToWrite)
-		if err != nil {
-			return 0, err
-		}
-	} else {
-		// write them separate
-		err := p.writeByteDirect(typeToWrite)
-		if err != nil {
-			return 0, err
-		}
-		err = p.WriteI16(id)
-		written = 1 + 2
-		if err != nil {
-			return 0, err
-		}
-	}
-
-	p.lastFieldId = fieldId
-	// p.lastField.Push(field.id);
-	return written, nil
-}
-
-func (p *TCompactProtocol) WriteFieldEnd() error { return nil }
-
-func (p *TCompactProtocol) WriteFieldStop() error {
-	err := p.writeByteDirect(STOP)
-	return NewTProtocolException(err)
-}
-
-func (p *TCompactProtocol) WriteMapBegin(keyType TType, valueType TType, size int) error {
-	if size == 0 {
-		err := p.writeByteDirect(0)
-		return NewTProtocolException(err)
-	}
-	_, err := p.writeVarint32(int32(size))
-	if err != nil {
-		return NewTProtocolException(err)
-	}
-	err = p.writeByteDirect(byte(p.getCompactType(keyType))<<4 | byte(p.getCompactType(valueType)))
-	return NewTProtocolException(err)
-}
-
-func (p *TCompactProtocol) WriteMapEnd() error { return nil }
-
-// Write a list header.
-func (p *TCompactProtocol) WriteListBegin(elemType TType, size int) error {
-	_, err := p.writeCollectionBegin(elemType, size)
-	return NewTProtocolException(err)
-}
-
-func (p *TCompactProtocol) WriteListEnd() error { return nil }
-
-// Write a set header.
-func (p *TCompactProtocol) WriteSetBegin(elemType TType, size int) error {
-	_, err := p.writeCollectionBegin(elemType, size)
-	return NewTProtocolException(err)
-}
-
-func (p *TCompactProtocol) WriteSetEnd() error { return nil }
-
-func (p *TCompactProtocol) WriteBool(value bool) error {
-	v := byte(COMPACT_BOOLEAN_FALSE)
-	if value {
-		v = byte(COMPACT_BOOLEAN_TRUE)
-	}
-	if p.booleanFieldPending {
-		// we haven't written the field header yet
-		_, err := p.writeFieldBeginInternal(p.booleanFieldName, BOOL, p.booleanFieldId, v)
-		p.booleanFieldPending = false
-		return NewTProtocolException(err)
-	}
-	// we're not part of a field, so just write the value.
-	err := p.writeByteDirect(v)
-	return NewTProtocolException(err)
-}
-
-// Write a byte. Nothing to see here!
-func (p *TCompactProtocol) WriteByte(value int8) error {
-	err := p.writeByteDirect(byte(value))
-	return NewTProtocolException(err)
-}
-
-// Write an I16 as a zigzag varint.
-func (p *TCompactProtocol) WriteI16(value int16) error {
-	_, err := p.writeVarint32(p.int32ToZigzag(int32(value)))
-	return NewTProtocolException(err)
-}
-
-// Write an i32 as a zigzag varint.
-func (p *TCompactProtocol) WriteI32(value int32) error {
-	_, err := p.writeVarint32(p.int32ToZigzag(value))
-	return NewTProtocolException(err)
-}
-
-// Write an i64 as a zigzag varint.
-func (p *TCompactProtocol) WriteI64(value int64) error {
-	_, err := p.writeVarint64(p.int64ToZigzag(value))
-	return NewTProtocolException(err)
-}
-
-// Write a double to the wire as 8 bytes.
-func (p *TCompactProtocol) WriteDouble(value float64) error {
-	buf := p.buffer[0:8]
-	binary.LittleEndian.PutUint64(buf, math.Float64bits(value))
-	_, err := p.trans.Write(buf)
-	return NewTProtocolException(err)
-}
-
-// Write a string to the wire with a varint size preceding.
-func (p *TCompactProtocol) WriteString(value string) error {
-	_, e := p.writeVarint32(int32(len(value)))
-	if e != nil {
-		return NewTProtocolException(e)
-	}
-	if len(value) > 0 {
-	}
-	_, e = p.trans.WriteString(value)
-	return e
-}
-
-// Write a byte array, using a varint for the size.
-func (p *TCompactProtocol) WriteBinary(bin []byte) error {
-	_, e := p.writeVarint32(int32(len(bin)))
-	if e != nil {
-		return NewTProtocolException(e)
-	}
-	if len(bin) > 0 {
-		_, e = p.trans.Write(bin)
-		return NewTProtocolException(e)
-	}
-	return nil
-}
-
-//
-// Reading methods.
-//
-
-// Read a message header.
-func (p *TCompactProtocol) ReadMessageBegin() (name string, typeId TMessageType, seqId int32, err error) {
-
-	protocolId, err := p.readByteDirect()
-	if err != nil {
-		return
-	}
-
-	if protocolId != COMPACT_PROTOCOL_ID {
-		e := fmt.Errorf("Expected protocol id %02x but got %02x", COMPACT_PROTOCOL_ID, protocolId)
-		return "", typeId, seqId, NewTProtocolExceptionWithType(BAD_VERSION, e)
-	}
-
-	versionAndType, err := p.readByteDirect()
-	if err != nil {
-		return
-	}
-
-	version := versionAndType & COMPACT_VERSION_MASK
-	typeId = TMessageType((versionAndType >> COMPACT_TYPE_SHIFT_AMOUNT) & COMPACT_TYPE_BITS)
-	if version != COMPACT_VERSION {
-		e := fmt.Errorf("Expected version %02x but got %02x", COMPACT_VERSION, version)
-		err = NewTProtocolExceptionWithType(BAD_VERSION, e)
-		return
-	}
-	seqId, e := p.readVarint32()
-	if e != nil {
-		err = NewTProtocolException(e)
-		return
-	}
-	name, err = p.ReadString()
-	return
-}
-
-func (p *TCompactProtocol) ReadMessageEnd() error { return nil }
-
-// Read a struct begin. There's nothing on the wire for this, but it is our
-// opportunity to push a new struct begin marker onto the field stack.
-func (p *TCompactProtocol) ReadStructBegin() (name string, err error) {
-	p.lastField = append(p.lastField, p.lastFieldId)
-	p.lastFieldId = 0
-	return
-}
-
-// Doesn't actually consume any wire data, just removes the last field for
-// this struct from the field stack.
-func (p *TCompactProtocol) ReadStructEnd() error {
-	// consume the last field we read off the wire.
-	p.lastFieldId = p.lastField[len(p.lastField)-1]
-	p.lastField = p.lastField[:len(p.lastField)-1]
-	return nil
-}
-
-// Read a field header off the wire.
-func (p *TCompactProtocol) ReadFieldBegin() (name string, typeId TType, id int16, err error) {
-	t, err := p.readByteDirect()
-	if err != nil {
-		return
-	}
-
-	// if it's a stop, then we can return immediately, as the struct is over.
-	if (t & 0x0f) == STOP {
-		return "", STOP, 0, nil
-	}
-
-	// mask off the 4 MSB of the type header. it could contain a field id delta.
-	modifier := int16((t & 0xf0) >> 4)
-	if modifier == 0 {
-		// not a delta. look ahead for the zigzag varint field id.
-		id, err = p.ReadI16()
-		if err != nil {
-			return
-		}
-	} else {
-		// has a delta. add the delta to the last read field id.
-		id = int16(p.lastFieldId) + modifier
-	}
-	typeId, e := p.getTType(tCompactType(t & 0x0f))
-	if e != nil {
-		err = NewTProtocolException(e)
-		return
-	}
-
-	// if this happens to be a boolean field, the value is encoded in the type
-	if p.isBoolType(t) {
-		// save the boolean value in a special instance variable.
-		p.boolValue = (byte(t)&0x0f == COMPACT_BOOLEAN_TRUE)
-		p.boolValueIsNotNull = true
-	}
-
-	// push the new field onto the field stack so we can keep the deltas going.
-	p.lastFieldId = int(id)
-	return
-}
-
-func (p *TCompactProtocol) ReadFieldEnd() error { return nil }
-
-// Read a map header off the wire. If the size is zero, skip reading the key
-// and value type. This means that 0-length maps will yield TMaps without the
-// "correct" types.
-func (p *TCompactProtocol) ReadMapBegin() (keyType TType, valueType TType, size int, err error) {
-	size32, e := p.readVarint32()
-	if e != nil {
-		err = NewTProtocolException(e)
-		return
-	}
-	if size32 < 0 {
-		err = invalidDataLength
-		return
-	}
-	size = int(size32)
-
-	keyAndValueType := byte(STOP)
-	if size != 0 {
-		keyAndValueType, err = p.readByteDirect()
-		if err != nil {
-			return
-		}
-	}
-	keyType, _ = p.getTType(tCompactType(keyAndValueType >> 4))
-	valueType, _ = p.getTType(tCompactType(keyAndValueType & 0xf))
-	return
-}
-
-func (p *TCompactProtocol) ReadMapEnd() error { return nil }
-
-// Read a list header off the wire. If the list size is 0-14, the size will
-// be packed into the element type header. If it's a longer list, the 4 MSB
-// of the element type header will be 0xF, and a varint will follow with the
-// true size.
-func (p *TCompactProtocol) ReadListBegin() (elemType TType, size int, err error) {
-	size_and_type, err := p.readByteDirect()
-	if err != nil {
-		return
-	}
-	size = int((size_and_type >> 4) & 0x0f)
-	if size == 15 {
-		size2, e := p.readVarint32()
-		if e != nil {
-			err = NewTProtocolException(e)
-			return
-		}
-		if size2 < 0 {
-			err = invalidDataLength
-			return
-		}
-		size = int(size2)
-	}
-	elemType, e := p.getTType(tCompactType(size_and_type))
-	if e != nil {
-		err = NewTProtocolException(e)
-		return
-	}
-	return
-}
-
-func (p *TCompactProtocol) ReadListEnd() error { return nil }
-
-// Read a set header off the wire. If the set size is 0-14, the size will
-// be packed into the element type header. If it's a longer set, the 4 MSB
-// of the element type header will be 0xF, and a varint will follow with the
-// true size.
-func (p *TCompactProtocol) ReadSetBegin() (elemType TType, size int, err error) {
-	return p.ReadListBegin()
-}
-
-func (p *TCompactProtocol) ReadSetEnd() error { return nil }
-
-// Read a boolean off the wire. If this is a boolean field, the value should
-// already have been read during readFieldBegin, so we'll just consume the
-// pre-stored value. Otherwise, read a byte.
-func (p *TCompactProtocol) ReadBool() (value bool, err error) {
-	if p.boolValueIsNotNull {
-		p.boolValueIsNotNull = false
-		return p.boolValue, nil
-	}
-	v, err := p.readByteDirect()
-	return v == COMPACT_BOOLEAN_TRUE, err
-}
-
-// Read a single byte off the wire. Nothing interesting here.
-func (p *TCompactProtocol) ReadByte() (int8, error) {
-	v, err := p.readByteDirect()
-	if err != nil {
-		return 0, NewTProtocolException(err)
-	}
-	return int8(v), err
-}
-
-// Read an i16 from the wire as a zigzag varint.
-func (p *TCompactProtocol) ReadI16() (value int16, err error) {
-	v, err := p.ReadI32()
-	return int16(v), err
-}
-
-// Read an i32 from the wire as a zigzag varint.
-func (p *TCompactProtocol) ReadI32() (value int32, err error) {
-	v, e := p.readVarint32()
-	if e != nil {
-		return 0, NewTProtocolException(e)
-	}
-	value = p.zigzagToInt32(v)
-	return value, nil
-}
-
-// Read an i64 from the wire as a zigzag varint.
-func (p *TCompactProtocol) ReadI64() (value int64, err error) {
-	v, e := p.readVarint64()
-	if e != nil {
-		return 0, NewTProtocolException(e)
-	}
-	value = p.zigzagToInt64(v)
-	return value, nil
-}
-
-// No magic here - just read a double off the wire.
-func (p *TCompactProtocol) ReadDouble() (value float64, err error) {
-	longBits := p.buffer[0:8]
-	_, e := io.ReadFull(p.trans, longBits)
-	if e != nil {
-		return 0.0, NewTProtocolException(e)
-	}
-	return math.Float64frombits(p.bytesToUint64(longBits)), nil
-}
-
-// Reads a []byte (via readBinary), and then UTF-8 decodes it.
-func (p *TCompactProtocol) ReadString() (value string, err error) {
-	length, e := p.readVarint32()
-	if e != nil {
-		return "", NewTProtocolException(e)
-	}
-	if length < 0 {
-		return "", invalidDataLength
-	}
-
-	if length == 0 {
-		return "", nil
-	}
-	var buf []byte
-	if length <= int32(len(p.buffer)) {
-		buf = p.buffer[0:length]
-	} else {
-		buf = make([]byte, length)
-	}
-	_, e = io.ReadFull(p.trans, buf)
-	return string(buf), NewTProtocolException(e)
-}
-
-// Read a []byte from the wire.
-func (p *TCompactProtocol) ReadBinary() (value []byte, err error) {
-	length, e := p.readVarint32()
-	if e != nil {
-		return nil, NewTProtocolException(e)
-	}
-	if length == 0 {
-		return []byte{}, nil
-	}
-	if length < 0 {
-		return nil, invalidDataLength
-	}
-
-	buf := make([]byte, length)
-	_, e = io.ReadFull(p.trans, buf)
-	return buf, NewTProtocolException(e)
-}
-
-func (p *TCompactProtocol) Flush(ctx context.Context) (err error) {
-	return NewTProtocolException(p.trans.Flush(ctx))
-}
-
-func (p *TCompactProtocol) Skip(fieldType TType) (err error) {
-	return SkipDefaultDepth(p, fieldType)
-}
-
-func (p *TCompactProtocol) Transport() TTransport {
-	return p.origTransport
-}
-
-//
-// Internal writing methods
-//
-
-// Abstract method for writing the start of lists and sets. List and sets on
-// the wire differ only by the type indicator.
-func (p *TCompactProtocol) writeCollectionBegin(elemType TType, size int) (int, error) {
-	if size <= 14 {
-		return 1, p.writeByteDirect(byte(int32(size<<4) | int32(p.getCompactType(elemType))))
-	}
-	err := p.writeByteDirect(0xf0 | byte(p.getCompactType(elemType)))
-	if err != nil {
-		return 0, err
-	}
-	m, err := p.writeVarint32(int32(size))
-	return 1 + m, err
-}
-
-// Write an i32 as a varint. Results in 1-5 bytes on the wire.
-// TODO(pomack): make a permanent buffer like writeVarint64?
-func (p *TCompactProtocol) writeVarint32(n int32) (int, error) {
-	i32buf := p.buffer[0:5]
-	idx := 0
-	for {
-		if (n & ^0x7F) == 0 {
-			i32buf[idx] = byte(n)
-			idx++
-			// p.writeByteDirect(byte(n));
-			break
-			// return;
-		} else {
-			i32buf[idx] = byte((n & 0x7F) | 0x80)
-			idx++
-			// p.writeByteDirect(byte(((n & 0x7F) | 0x80)));
-			u := uint32(n)
-			n = int32(u >> 7)
-		}
-	}
-	return p.trans.Write(i32buf[0:idx])
-}
-
-// Write an i64 as a varint. Results in 1-10 bytes on the wire.
-func (p *TCompactProtocol) writeVarint64(n int64) (int, error) {
-	varint64out := p.buffer[0:10]
-	idx := 0
-	for {
-		if (n & ^0x7F) == 0 {
-			varint64out[idx] = byte(n)
-			idx++
-			break
-		} else {
-			varint64out[idx] = byte((n & 0x7F) | 0x80)
-			idx++
-			u := uint64(n)
-			n = int64(u >> 7)
-		}
-	}
-	return p.trans.Write(varint64out[0:idx])
-}
-
-// Convert l into a zigzag long. This allows negative numbers to be
-// represented compactly as a varint.
-func (p *TCompactProtocol) int64ToZigzag(l int64) int64 {
-	return (l << 1) ^ (l >> 63)
-}
-
-// Convert l into a zigzag long. This allows negative numbers to be
-// represented compactly as a varint.
-func (p *TCompactProtocol) int32ToZigzag(n int32) int32 {
-	return (n << 1) ^ (n >> 31)
-}
-
-func (p *TCompactProtocol) fixedUint64ToBytes(n uint64, buf []byte) {
-	binary.LittleEndian.PutUint64(buf, n)
-}
-
-func (p *TCompactProtocol) fixedInt64ToBytes(n int64, buf []byte) {
-	binary.LittleEndian.PutUint64(buf, uint64(n))
-}
-
-// Writes a byte without any possibility of all that field header nonsense.
-// Used internally by other writing methods that know they need to write a byte.
-func (p *TCompactProtocol) writeByteDirect(b byte) error {
-	return p.trans.WriteByte(b)
-}
-
-// Writes a byte without any possibility of all that field header nonsense.
-func (p *TCompactProtocol) writeIntAsByteDirect(n int) (int, error) {
-	return 1, p.writeByteDirect(byte(n))
-}
-
-//
-// Internal reading methods
-//
-
-// Read an i32 from the wire as a varint. The MSB of each byte is set
-// if there is another byte to follow. This can read up to 5 bytes.
-func (p *TCompactProtocol) readVarint32() (int32, error) {
-	// if the wire contains the right stuff, this will just truncate the i64 we
-	// read and get us the right sign.
-	v, err := p.readVarint64()
-	return int32(v), err
-}
-
-// Read an i64 from the wire as a proper varint. The MSB of each byte is set
-// if there is another byte to follow. This can read up to 10 bytes.
-func (p *TCompactProtocol) readVarint64() (int64, error) {
-	shift := uint(0)
-	result := int64(0)
-	for {
-		b, err := p.readByteDirect()
-		if err != nil {
-			return 0, err
-		}
-		result |= int64(b&0x7f) << shift
-		if (b & 0x80) != 0x80 {
-			break
-		}
-		shift += 7
-	}
-	return result, nil
-}
-
-// Read a byte, unlike ReadByte that reads Thrift-byte that is i8.
-func (p *TCompactProtocol) readByteDirect() (byte, error) {
-	return p.trans.ReadByte()
-}
-
-//
-// encoding helpers
-//
-
-// Convert from zigzag int to int.
-func (p *TCompactProtocol) zigzagToInt32(n int32) int32 {
-	u := uint32(n)
-	return int32(u>>1) ^ -(n & 1)
-}
-
-// Convert from zigzag long to long.
-func (p *TCompactProtocol) zigzagToInt64(n int64) int64 {
-	u := uint64(n)
-	return int64(u>>1) ^ -(n & 1)
-}
-
-// Note that it's important that the mask bytes are long literals,
-// otherwise they'll default to ints, and when you shift an int left 56 bits,
-// you just get a messed up int.
-func (p *TCompactProtocol) bytesToInt64(b []byte) int64 {
-	return int64(binary.LittleEndian.Uint64(b))
-}
-
-// Note that it's important that the mask bytes are long literals,
-// otherwise they'll default to ints, and when you shift an int left 56 bits,
-// you just get a messed up int.
-func (p *TCompactProtocol) bytesToUint64(b []byte) uint64 {
-	return binary.LittleEndian.Uint64(b)
-}
-
-//
-// type testing and converting
-//
-
-func (p *TCompactProtocol) isBoolType(b byte) bool {
-	return (b&0x0f) == COMPACT_BOOLEAN_TRUE || (b&0x0f) == COMPACT_BOOLEAN_FALSE
-}
-
-// Given a tCompactType constant, convert it to its corresponding
-// TType value.
-func (p *TCompactProtocol) getTType(t tCompactType) (TType, error) {
-	switch byte(t) & 0x0f {
-	case STOP:
-		return STOP, nil
-	case COMPACT_BOOLEAN_FALSE, COMPACT_BOOLEAN_TRUE:
-		return BOOL, nil
-	case COMPACT_BYTE:
-		return BYTE, nil
-	case COMPACT_I16:
-		return I16, nil
-	case COMPACT_I32:
-		return I32, nil
-	case COMPACT_I64:
-		return I64, nil
-	case COMPACT_DOUBLE:
-		return DOUBLE, nil
-	case COMPACT_BINARY:
-		return STRING, nil
-	case COMPACT_LIST:
-		return LIST, nil
-	case COMPACT_SET:
-		return SET, nil
-	case COMPACT_MAP:
-		return MAP, nil
-	case COMPACT_STRUCT:
-		return STRUCT, nil
-	}
-	return STOP, TException(fmt.Errorf("don't know what type: %v", t&0x0f))
-}
-
-// Given a TType value, find the appropriate TCompactProtocol.Types constant.
-func (p *TCompactProtocol) getCompactType(t TType) tCompactType {
-	return ttypeToCompactType[t]
-}

vendor/github.com/apache/thrift/lib/go/thrift/compact_protocol_test.go

@@ -1,60 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"bytes"
-	"testing"
-)
-
-func TestReadWriteCompactProtocol(t *testing.T) {
-	ReadWriteProtocolTest(t, NewTCompactProtocolFactory())
-
-	transports := []TTransport{
-		NewTMemoryBuffer(),
-		NewStreamTransportRW(bytes.NewBuffer(make([]byte, 0, 16384))),
-		NewTFramedTransport(NewTMemoryBuffer()),
-	}
-
-	zlib0, _ := NewTZlibTransport(NewTMemoryBuffer(), 0)
-	zlib6, _ := NewTZlibTransport(NewTMemoryBuffer(), 6)
-	zlib9, _ := NewTZlibTransport(NewTFramedTransport(NewTMemoryBuffer()), 9)
-	transports = append(transports, zlib0, zlib6, zlib9)
-
-	for _, trans := range transports {
-		p := NewTCompactProtocol(trans)
-		ReadWriteBool(t, p, trans)
-		p = NewTCompactProtocol(trans)
-		ReadWriteByte(t, p, trans)
-		p = NewTCompactProtocol(trans)
-		ReadWriteI16(t, p, trans)
-		p = NewTCompactProtocol(trans)
-		ReadWriteI32(t, p, trans)
-		p = NewTCompactProtocol(trans)
-		ReadWriteI64(t, p, trans)
-		p = NewTCompactProtocol(trans)
-		ReadWriteDouble(t, p, trans)
-		p = NewTCompactProtocol(trans)
-		ReadWriteString(t, p, trans)
-		p = NewTCompactProtocol(trans)
-		ReadWriteBinary(t, p, trans)
-		trans.Close()
-	}
-}

vendor/github.com/apache/thrift/lib/go/thrift/context.go

@@ -1,24 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import "context"
-
-var defaultCtx = context.Background()

vendor/github.com/apache/thrift/lib/go/thrift/debug_protocol.go

@@ -1,270 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"context"
-	"log"
-)
-
-type TDebugProtocol struct {
-	Delegate  TProtocol
-	LogPrefix string
-}
-
-type TDebugProtocolFactory struct {
-	Underlying TProtocolFactory
-	LogPrefix  string
-}
-
-func NewTDebugProtocolFactory(underlying TProtocolFactory, logPrefix string) *TDebugProtocolFactory {
-	return &TDebugProtocolFactory{
-		Underlying: underlying,
-		LogPrefix:  logPrefix,
-	}
-}
-
-func (t *TDebugProtocolFactory) GetProtocol(trans TTransport) TProtocol {
-	return &TDebugProtocol{
-		Delegate:  t.Underlying.GetProtocol(trans),
-		LogPrefix: t.LogPrefix,
-	}
-}
-
-func (tdp *TDebugProtocol) WriteMessageBegin(name string, typeId TMessageType, seqid int32) error {
-	err := tdp.Delegate.WriteMessageBegin(name, typeId, seqid)
-	log.Printf("%sWriteMessageBegin(name=%#v, typeId=%#v, seqid=%#v) => %#v", tdp.LogPrefix, name, typeId, seqid, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteMessageEnd() error {
-	err := tdp.Delegate.WriteMessageEnd()
-	log.Printf("%sWriteMessageEnd() => %#v", tdp.LogPrefix, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteStructBegin(name string) error {
-	err := tdp.Delegate.WriteStructBegin(name)
-	log.Printf("%sWriteStructBegin(name=%#v) => %#v", tdp.LogPrefix, name, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteStructEnd() error {
-	err := tdp.Delegate.WriteStructEnd()
-	log.Printf("%sWriteStructEnd() => %#v", tdp.LogPrefix, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteFieldBegin(name string, typeId TType, id int16) error {
-	err := tdp.Delegate.WriteFieldBegin(name, typeId, id)
-	log.Printf("%sWriteFieldBegin(name=%#v, typeId=%#v, id%#v) => %#v", tdp.LogPrefix, name, typeId, id, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteFieldEnd() error {
-	err := tdp.Delegate.WriteFieldEnd()
-	log.Printf("%sWriteFieldEnd() => %#v", tdp.LogPrefix, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteFieldStop() error {
-	err := tdp.Delegate.WriteFieldStop()
-	log.Printf("%sWriteFieldStop() => %#v", tdp.LogPrefix, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteMapBegin(keyType TType, valueType TType, size int) error {
-	err := tdp.Delegate.WriteMapBegin(keyType, valueType, size)
-	log.Printf("%sWriteMapBegin(keyType=%#v, valueType=%#v, size=%#v) => %#v", tdp.LogPrefix, keyType, valueType, size, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteMapEnd() error {
-	err := tdp.Delegate.WriteMapEnd()
-	log.Printf("%sWriteMapEnd() => %#v", tdp.LogPrefix, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteListBegin(elemType TType, size int) error {
-	err := tdp.Delegate.WriteListBegin(elemType, size)
-	log.Printf("%sWriteListBegin(elemType=%#v, size=%#v) => %#v", tdp.LogPrefix, elemType, size, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteListEnd() error {
-	err := tdp.Delegate.WriteListEnd()
-	log.Printf("%sWriteListEnd() => %#v", tdp.LogPrefix, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteSetBegin(elemType TType, size int) error {
-	err := tdp.Delegate.WriteSetBegin(elemType, size)
-	log.Printf("%sWriteSetBegin(elemType=%#v, size=%#v) => %#v", tdp.LogPrefix, elemType, size, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteSetEnd() error {
-	err := tdp.Delegate.WriteSetEnd()
-	log.Printf("%sWriteSetEnd() => %#v", tdp.LogPrefix, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteBool(value bool) error {
-	err := tdp.Delegate.WriteBool(value)
-	log.Printf("%sWriteBool(value=%#v) => %#v", tdp.LogPrefix, value, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteByte(value int8) error {
-	err := tdp.Delegate.WriteByte(value)
-	log.Printf("%sWriteByte(value=%#v) => %#v", tdp.LogPrefix, value, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteI16(value int16) error {
-	err := tdp.Delegate.WriteI16(value)
-	log.Printf("%sWriteI16(value=%#v) => %#v", tdp.LogPrefix, value, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteI32(value int32) error {
-	err := tdp.Delegate.WriteI32(value)
-	log.Printf("%sWriteI32(value=%#v) => %#v", tdp.LogPrefix, value, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteI64(value int64) error {
-	err := tdp.Delegate.WriteI64(value)
-	log.Printf("%sWriteI64(value=%#v) => %#v", tdp.LogPrefix, value, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteDouble(value float64) error {
-	err := tdp.Delegate.WriteDouble(value)
-	log.Printf("%sWriteDouble(value=%#v) => %#v", tdp.LogPrefix, value, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteString(value string) error {
-	err := tdp.Delegate.WriteString(value)
-	log.Printf("%sWriteString(value=%#v) => %#v", tdp.LogPrefix, value, err)
-	return err
-}
-func (tdp *TDebugProtocol) WriteBinary(value []byte) error {
-	err := tdp.Delegate.WriteBinary(value)
-	log.Printf("%sWriteBinary(value=%#v) => %#v", tdp.LogPrefix, value, err)
-	return err
-}
-
-func (tdp *TDebugProtocol) ReadMessageBegin() (name string, typeId TMessageType, seqid int32, err error) {
-	name, typeId, seqid, err = tdp.Delegate.ReadMessageBegin()
-	log.Printf("%sReadMessageBegin() (name=%#v, typeId=%#v, seqid=%#v, err=%#v)", tdp.LogPrefix, name, typeId, seqid, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadMessageEnd() (err error) {
-	err = tdp.Delegate.ReadMessageEnd()
-	log.Printf("%sReadMessageEnd() err=%#v", tdp.LogPrefix, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadStructBegin() (name string, err error) {
-	name, err = tdp.Delegate.ReadStructBegin()
-	log.Printf("%sReadStructBegin() (name%#v, err=%#v)", tdp.LogPrefix, name, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadStructEnd() (err error) {
-	err = tdp.Delegate.ReadStructEnd()
-	log.Printf("%sReadStructEnd() err=%#v", tdp.LogPrefix, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadFieldBegin() (name string, typeId TType, id int16, err error) {
-	name, typeId, id, err = tdp.Delegate.ReadFieldBegin()
-	log.Printf("%sReadFieldBegin() (name=%#v, typeId=%#v, id=%#v, err=%#v)", tdp.LogPrefix, name, typeId, id, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadFieldEnd() (err error) {
-	err = tdp.Delegate.ReadFieldEnd()
-	log.Printf("%sReadFieldEnd() err=%#v", tdp.LogPrefix, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadMapBegin() (keyType TType, valueType TType, size int, err error) {
-	keyType, valueType, size, err = tdp.Delegate.ReadMapBegin()
-	log.Printf("%sReadMapBegin() (keyType=%#v, valueType=%#v, size=%#v, err=%#v)", tdp.LogPrefix, keyType, valueType, size, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadMapEnd() (err error) {
-	err = tdp.Delegate.ReadMapEnd()
-	log.Printf("%sReadMapEnd() err=%#v", tdp.LogPrefix, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadListBegin() (elemType TType, size int, err error) {
-	elemType, size, err = tdp.Delegate.ReadListBegin()
-	log.Printf("%sReadListBegin() (elemType=%#v, size=%#v, err=%#v)", tdp.LogPrefix, elemType, size, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadListEnd() (err error) {
-	err = tdp.Delegate.ReadListEnd()
-	log.Printf("%sReadListEnd() err=%#v", tdp.LogPrefix, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadSetBegin() (elemType TType, size int, err error) {
-	elemType, size, err = tdp.Delegate.ReadSetBegin()
-	log.Printf("%sReadSetBegin() (elemType=%#v, size=%#v, err=%#v)", tdp.LogPrefix, elemType, size, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadSetEnd() (err error) {
-	err = tdp.Delegate.ReadSetEnd()
-	log.Printf("%sReadSetEnd() err=%#v", tdp.LogPrefix, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadBool() (value bool, err error) {
-	value, err = tdp.Delegate.ReadBool()
-	log.Printf("%sReadBool() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadByte() (value int8, err error) {
-	value, err = tdp.Delegate.ReadByte()
-	log.Printf("%sReadByte() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadI16() (value int16, err error) {
-	value, err = tdp.Delegate.ReadI16()
-	log.Printf("%sReadI16() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadI32() (value int32, err error) {
-	value, err = tdp.Delegate.ReadI32()
-	log.Printf("%sReadI32() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadI64() (value int64, err error) {
-	value, err = tdp.Delegate.ReadI64()
-	log.Printf("%sReadI64() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadDouble() (value float64, err error) {
-	value, err = tdp.Delegate.ReadDouble()
-	log.Printf("%sReadDouble() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadString() (value string, err error) {
-	value, err = tdp.Delegate.ReadString()
-	log.Printf("%sReadString() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
-	return
-}
-func (tdp *TDebugProtocol) ReadBinary() (value []byte, err error) {
-	value, err = tdp.Delegate.ReadBinary()
-	log.Printf("%sReadBinary() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
-	return
-}
-func (tdp *TDebugProtocol) Skip(fieldType TType) (err error) {
-	err = tdp.Delegate.Skip(fieldType)
-	log.Printf("%sSkip(fieldType=%#v) (err=%#v)", tdp.LogPrefix, fieldType, err)
-	return
-}
-func (tdp *TDebugProtocol) Flush(ctx context.Context) (err error) {
-	err = tdp.Delegate.Flush(ctx)
-	log.Printf("%sFlush() (err=%#v)", tdp.LogPrefix, err)
-	return
-}
-
-func (tdp *TDebugProtocol) Transport() TTransport {
-	return tdp.Delegate.Transport()
-}

vendor/github.com/apache/thrift/lib/go/thrift/deserializer.go

@@ -1,58 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-type TDeserializer struct {
-	Transport TTransport
-	Protocol  TProtocol
-}
-
-func NewTDeserializer() *TDeserializer {
-	var transport TTransport
-	transport = NewTMemoryBufferLen(1024)
-
-	protocol := NewTBinaryProtocolFactoryDefault().GetProtocol(transport)
-
-	return &TDeserializer{
-		transport,
-		protocol}
-}
-
-func (t *TDeserializer) ReadString(msg TStruct, s string) (err error) {
-	err = nil
-	if _, err = t.Transport.Write([]byte(s)); err != nil {
-		return
-	}
-	if err = msg.Read(t.Protocol); err != nil {
-		return
-	}
-	return
-}
-
-func (t *TDeserializer) Read(msg TStruct, b []byte) (err error) {
-	err = nil
-	if _, err = t.Transport.Write(b); err != nil {
-		return
-	}
-	if err = msg.Read(t.Protocol); err != nil {
-		return
-	}
-	return
-}

vendor/github.com/apache/thrift/lib/go/thrift/exception.go

@@ -1,44 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"errors"
-)
-
-// Generic Thrift exception
-type TException interface {
-	error
-}
-
-// Prepends additional information to an error without losing the Thrift exception interface
-func PrependError(prepend string, err error) error {
-	if t, ok := err.(TTransportException); ok {
-		return NewTTransportException(t.TypeId(), prepend+t.Error())
-	}
-	if t, ok := err.(TProtocolException); ok {
-		return NewTProtocolExceptionWithType(t.TypeId(), errors.New(prepend+err.Error()))
-	}
-	if t, ok := err.(TApplicationException); ok {
-		return NewTApplicationException(t.TypeId(), prepend+t.Error())
-	}
-
-	return errors.New(prepend + err.Error())
-}

vendor/github.com/apache/thrift/lib/go/thrift/exception_test.go

@@ -1,69 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestPrependError(t *testing.T) {
-	err := NewTApplicationException(INTERNAL_ERROR, "original error")
-	err2, ok := PrependError("Prepend: ", err).(TApplicationException)
-	if !ok {
-		t.Fatal("Couldn't cast error TApplicationException")
-	}
-	if err2.Error() != "Prepend: original error" {
-		t.Fatal("Unexpected error string")
-	}
-	if err2.TypeId() != INTERNAL_ERROR {
-		t.Fatal("Unexpected type error")
-	}
-
-	err3 := NewTProtocolExceptionWithType(INVALID_DATA, errors.New("original error"))
-	err4, ok := PrependError("Prepend: ", err3).(TProtocolException)
-	if !ok {
-		t.Fatal("Couldn't cast error TProtocolException")
-	}
-	if err4.Error() != "Prepend: original error" {
-		t.Fatal("Unexpected error string")
-	}
-	if err4.TypeId() != INVALID_DATA {
-		t.Fatal("Unexpected type error")
-	}
-
-	err5 := NewTTransportException(TIMED_OUT, "original error")
-	err6, ok := PrependError("Prepend: ", err5).(TTransportException)
-	if !ok {
-		t.Fatal("Couldn't cast error TTransportException")
-	}
-	if err6.Error() != "Prepend: original error" {
-		t.Fatal("Unexpected error string")
-	}
-	if err6.TypeId() != TIMED_OUT {
-		t.Fatal("Unexpected type error")
-	}
-
-	err7 := errors.New("original error")
-	err8 := PrependError("Prepend: ", err7)
-	if err8.Error() != "Prepend: original error" {
-		t.Fatal("Unexpected error string")
-	}
-}

vendor/github.com/apache/thrift/lib/go/thrift/field.go

@@ -1,79 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-// Helper class that encapsulates field metadata.
-type field struct {
-	name   string
-	typeId TType
-	id     int
-}
-
-func newField(n string, t TType, i int) *field {
-	return &field{name: n, typeId: t, id: i}
-}
-
-func (p *field) Name() string {
-	if p == nil {
-		return ""
-	}
-	return p.name
-}
-
-func (p *field) TypeId() TType {
-	if p == nil {
-		return TType(VOID)
-	}
-	return p.typeId
-}
-
-func (p *field) Id() int {
-	if p == nil {
-		return -1
-	}
-	return p.id
-}
-
-func (p *field) String() string {
-	if p == nil {
-		return "<nil>"
-	}
-	return "<TField name:'" + p.name + "' type:" + string(p.typeId) + " field-id:" + string(p.id) + ">"
-}
-
-var ANONYMOUS_FIELD *field
-
-type fieldSlice []field
-
-func (p fieldSlice) Len() int {
-	return len(p)
-}
-
-func (p fieldSlice) Less(i, j int) bool {
-	return p[i].Id() < p[j].Id()
-}
-
-func (p fieldSlice) Swap(i, j int) {
-	p[i], p[j] = p[j], p[i]
-}
-
-func init() {
-	ANONYMOUS_FIELD = newField("", STOP, 0)
-}

vendor/github.com/apache/thrift/lib/go/thrift/framed_transport.go

@@ -1,173 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"encoding/binary"
-	"fmt"
-	"io"
-)
-
-const DEFAULT_MAX_LENGTH = 16384000
-
-type TFramedTransport struct {
-	transport TTransport
-	buf       bytes.Buffer
-	reader    *bufio.Reader
-	frameSize uint32 //Current remaining size of the frame. if ==0 read next frame header
-	buffer    [4]byte
-	maxLength uint32
-}
-
-type tFramedTransportFactory struct {
-	factory   TTransportFactory
-	maxLength uint32
-}
-
-func NewTFramedTransportFactory(factory TTransportFactory) TTransportFactory {
-	return &tFramedTransportFactory{factory: factory, maxLength: DEFAULT_MAX_LENGTH}
-}
-
-func NewTFramedTransportFactoryMaxLength(factory TTransportFactory, maxLength uint32) TTransportFactory {
-	return &tFramedTransportFactory{factory: factory, maxLength: maxLength}
-}
-
-func (p *tFramedTransportFactory) GetTransport(base TTransport) (TTransport, error) {
-	tt, err := p.factory.GetTransport(base)
-	if err != nil {
-		return nil, err
-	}
-	return NewTFramedTransportMaxLength(tt, p.maxLength), nil
-}
-
-func NewTFramedTransport(transport TTransport) *TFramedTransport {
-	return &TFramedTransport{transport: transport, reader: bufio.NewReader(transport), maxLength: DEFAULT_MAX_LENGTH}
-}
-
-func NewTFramedTransportMaxLength(transport TTransport, maxLength uint32) *TFramedTransport {
-	return &TFramedTransport{transport: transport, reader: bufio.NewReader(transport), maxLength: maxLength}
-}
-
-func (p *TFramedTransport) Open() error {
-	return p.transport.Open()
-}
-
-func (p *TFramedTransport) IsOpen() bool {
-	return p.transport.IsOpen()
-}
-
-func (p *TFramedTransport) Close() error {
-	return p.transport.Close()
-}
-
-func (p *TFramedTransport) Read(buf []byte) (l int, err error) {
-	if p.frameSize == 0 {
-		p.frameSize, err = p.readFrameHeader()
-		if err != nil {
-			return
-		}
-	}
-	if p.frameSize < uint32(len(buf)) {
-		frameSize := p.frameSize
-		tmp := make([]byte, p.frameSize)
-		l, err = p.Read(tmp)
-		copy(buf, tmp)
-		if err == nil {
-			err = NewTTransportExceptionFromError(fmt.Errorf("Not enough frame size %d to read %d bytes", frameSize, len(buf)))
-			return
-		}
-	}
-	got, err := p.reader.Read(buf)
-	p.frameSize = p.frameSize - uint32(got)
-	//sanity check
-	if p.frameSize < 0 {
-		return 0, NewTTransportException(UNKNOWN_TRANSPORT_EXCEPTION, "Negative frame size")
-	}
-	return got, NewTTransportExceptionFromError(err)
-}
-
-func (p *TFramedTransport) ReadByte() (c byte, err error) {
-	if p.frameSize == 0 {
-		p.frameSize, err = p.readFrameHeader()
-		if err != nil {
-			return
-		}
-	}
-	if p.frameSize < 1 {
-		return 0, NewTTransportExceptionFromError(fmt.Errorf("Not enough frame size %d to read %d bytes", p.frameSize, 1))
-	}
-	c, err = p.reader.ReadByte()
-	if err == nil {
-		p.frameSize--
-	}
-	return
-}
-
-func (p *TFramedTransport) Write(buf []byte) (int, error) {
-	n, err := p.buf.Write(buf)
-	return n, NewTTransportExceptionFromError(err)
-}
-
-func (p *TFramedTransport) WriteByte(c byte) error {
-	return p.buf.WriteByte(c)
-}
-
-func (p *TFramedTransport) WriteString(s string) (n int, err error) {
-	return p.buf.WriteString(s)
-}
-
-func (p *TFramedTransport) Flush(ctx context.Context) error {
-	size := p.buf.Len()
-	buf := p.buffer[:4]
-	binary.BigEndian.PutUint32(buf, uint32(size))
-	_, err := p.transport.Write(buf)
-	if err != nil {
-		p.buf.Truncate(0)
-		return NewTTransportExceptionFromError(err)
-	}
-	if size > 0 {
-		if n, err := p.buf.WriteTo(p.transport); err != nil {
-			print("Error while flushing write buffer of size ", size, " to transport, only wrote ", n, " bytes: ", err.Error(), "\n")
-			p.buf.Truncate(0)
-			return NewTTransportExceptionFromError(err)
-		}
-	}
-	err = p.transport.Flush(ctx)
-	return NewTTransportExceptionFromError(err)
-}
-
-func (p *TFramedTransport) readFrameHeader() (uint32, error) {
-	buf := p.buffer[:4]
-	if _, err := io.ReadFull(p.reader, buf); err != nil {
-		return 0, err
-	}
-	size := binary.BigEndian.Uint32(buf)
-	if size < 0 || size > p.maxLength {
-		return 0, NewTTransportException(UNKNOWN_TRANSPORT_EXCEPTION, fmt.Sprintf("Incorrect frame size (%d)", size))
-	}
-	return size, nil
-}
-
-func (p *TFramedTransport) RemainingBytes() (num_bytes uint64) {
-	return uint64(p.frameSize)
-}

vendor/github.com/apache/thrift/lib/go/thrift/framed_transport_test.go

@@ -1,29 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"testing"
-)
-
-func TestFramedTransport(t *testing.T) {
-	trans := NewTFramedTransport(NewTMemoryBuffer())
-	TransportTest(t, trans, trans)
-}

vendor/github.com/apache/thrift/lib/go/thrift/http_client.go

@@ -1,242 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"bytes"
-	"context"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"strconv"
-)
-
-// Default to using the shared http client. Library users are
-// free to change this global client or specify one through
-// THttpClientOptions.
-var DefaultHttpClient *http.Client = http.DefaultClient
-
-type THttpClient struct {
-	client             *http.Client
-	response           *http.Response
-	url                *url.URL
-	requestBuffer      *bytes.Buffer
-	header             http.Header
-	nsecConnectTimeout int64
-	nsecReadTimeout    int64
-}
-
-type THttpClientTransportFactory struct {
-	options THttpClientOptions
-	url     string
-}
-
-func (p *THttpClientTransportFactory) GetTransport(trans TTransport) (TTransport, error) {
-	if trans != nil {
-		t, ok := trans.(*THttpClient)
-		if ok && t.url != nil {
-			return NewTHttpClientWithOptions(t.url.String(), p.options)
-		}
-	}
-	return NewTHttpClientWithOptions(p.url, p.options)
-}
-
-type THttpClientOptions struct {
-	// If nil, DefaultHttpClient is used
-	Client *http.Client
-}
-
-func NewTHttpClientTransportFactory(url string) *THttpClientTransportFactory {
-	return NewTHttpClientTransportFactoryWithOptions(url, THttpClientOptions{})
-}
-
-func NewTHttpClientTransportFactoryWithOptions(url string, options THttpClientOptions) *THttpClientTransportFactory {
-	return &THttpClientTransportFactory{url: url, options: options}
-}
-
-func NewTHttpClientWithOptions(urlstr string, options THttpClientOptions) (TTransport, error) {
-	parsedURL, err := url.Parse(urlstr)
-	if err != nil {
-		return nil, err
-	}
-	buf := make([]byte, 0, 1024)
-	client := options.Client
-	if client == nil {
-		client = DefaultHttpClient
-	}
-	httpHeader := map[string][]string{"Content-Type": {"application/x-thrift"}}
-	return &THttpClient{client: client, url: parsedURL, requestBuffer: bytes.NewBuffer(buf), header: httpHeader}, nil
-}
-
-func NewTHttpClient(urlstr string) (TTransport, error) {
-	return NewTHttpClientWithOptions(urlstr, THttpClientOptions{})
-}
-
-// Set the HTTP Header for this specific Thrift Transport
-// It is important that you first assert the TTransport as a THttpClient type
-// like so:
-//
-// httpTrans := trans.(THttpClient)
-// httpTrans.SetHeader("User-Agent","Thrift Client 1.0")
-func (p *THttpClient) SetHeader(key string, value string) {
-	p.header.Add(key, value)
-}
-
-// Get the HTTP Header represented by the supplied Header Key for this specific Thrift Transport
-// It is important that you first assert the TTransport as a THttpClient type
-// like so:
-//
-// httpTrans := trans.(THttpClient)
-// hdrValue := httpTrans.GetHeader("User-Agent")
-func (p *THttpClient) GetHeader(key string) string {
-	return p.header.Get(key)
-}
-
-// Deletes the HTTP Header given a Header Key for this specific Thrift Transport
-// It is important that you first assert the TTransport as a THttpClient type
-// like so:
-//
-// httpTrans := trans.(THttpClient)
-// httpTrans.DelHeader("User-Agent")
-func (p *THttpClient) DelHeader(key string) {
-	p.header.Del(key)
-}
-
-func (p *THttpClient) Open() error {
-	// do nothing
-	return nil
-}
-
-func (p *THttpClient) IsOpen() bool {
-	return p.response != nil || p.requestBuffer != nil
-}
-
-func (p *THttpClient) closeResponse() error {
-	var err error
-	if p.response != nil && p.response.Body != nil {
-		// The docs specify that if keepalive is enabled and the response body is not
-		// read to completion the connection will never be returned to the pool and
-		// reused. Errors are being ignored here because if the connection is invalid
-		// and this fails for some reason, the Close() method will do any remaining
-		// cleanup.
-		io.Copy(ioutil.Discard, p.response.Body)
-
-		err = p.response.Body.Close()
-	}
-
-	p.response = nil
-	return err
-}
-
-func (p *THttpClient) Close() error {
-	if p.requestBuffer != nil {
-		p.requestBuffer.Reset()
-		p.requestBuffer = nil
-	}
-	return p.closeResponse()
-}
-
-func (p *THttpClient) Read(buf []byte) (int, error) {
-	if p.response == nil {
-		return 0, NewTTransportException(NOT_OPEN, "Response buffer is empty, no request.")
-	}
-	n, err := p.response.Body.Read(buf)
-	if n > 0 && (err == nil || err == io.EOF) {
-		return n, nil
-	}
-	return n, NewTTransportExceptionFromError(err)
-}
-
-func (p *THttpClient) ReadByte() (c byte, err error) {
-	return readByte(p.response.Body)
-}
-
-func (p *THttpClient) Write(buf []byte) (int, error) {
-	n, err := p.requestBuffer.Write(buf)
-	return n, err
-}
-
-func (p *THttpClient) WriteByte(c byte) error {
-	return p.requestBuffer.WriteByte(c)
-}
-
-func (p *THttpClient) WriteString(s string) (n int, err error) {
-	return p.requestBuffer.WriteString(s)
-}
-
-func (p *THttpClient) Flush(ctx context.Context) error {
-	// Close any previous response body to avoid leaking connections.
-	p.closeResponse()
-
-	req, err := http.NewRequest("POST", p.url.String(), p.requestBuffer)
-	if err != nil {
-		return NewTTransportExceptionFromError(err)
-	}
-	req.Header = p.header
-	if ctx != nil {
-		req = req.WithContext(ctx)
-	}
-	response, err := p.client.Do(req)
-	if err != nil {
-		return NewTTransportExceptionFromError(err)
-	}
-	if response.StatusCode != http.StatusOK {
-		// Close the response to avoid leaking file descriptors. closeResponse does
-		// more than just call Close(), so temporarily assign it and reuse the logic.
-		p.response = response
-		p.closeResponse()
-
-		// TODO(pomack) log bad response
-		return NewTTransportException(UNKNOWN_TRANSPORT_EXCEPTION, "HTTP Response code: "+strconv.Itoa(response.StatusCode))
-	}
-	p.response = response
-	return nil
-}
-
-func (p *THttpClient) RemainingBytes() (num_bytes uint64) {
-	len := p.response.ContentLength
-	if len >= 0 {
-		return uint64(len)
-	}
-
-	const maxSize = ^uint64(0)
-	return maxSize // the thruth is, we just don't know unless framed is used
-}
-
-// Deprecated: Use NewTHttpClientTransportFactory instead.
-func NewTHttpPostClientTransportFactory(url string) *THttpClientTransportFactory {
-	return NewTHttpClientTransportFactoryWithOptions(url, THttpClientOptions{})
-}
-
-// Deprecated: Use NewTHttpClientTransportFactoryWithOptions instead.
-func NewTHttpPostClientTransportFactoryWithOptions(url string, options THttpClientOptions) *THttpClientTransportFactory {
-	return NewTHttpClientTransportFactoryWithOptions(url, options)
-}
-
-// Deprecated: Use NewTHttpClientWithOptions instead.
-func NewTHttpPostClientWithOptions(urlstr string, options THttpClientOptions) (TTransport, error) {
-	return NewTHttpClientWithOptions(urlstr, options)
-}
-
-// Deprecated: Use NewTHttpClient instead.
-func NewTHttpPostClient(urlstr string) (TTransport, error) {
-	return NewTHttpClientWithOptions(urlstr, THttpClientOptions{})
-}

vendor/github.com/apache/thrift/lib/go/thrift/http_client_test.go

@@ -1,106 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"net/http"
-	"testing"
-)
-
-func TestHttpClient(t *testing.T) {
-	l, addr := HttpClientSetupForTest(t)
-	if l != nil {
-		defer l.Close()
-	}
-	trans, err := NewTHttpPostClient("http://" + addr.String())
-	if err != nil {
-		l.Close()
-		t.Fatalf("Unable to connect to %s: %s", addr.String(), err)
-	}
-	TransportTest(t, trans, trans)
-}
-
-func TestHttpClientHeaders(t *testing.T) {
-	l, addr := HttpClientSetupForTest(t)
-	if l != nil {
-		defer l.Close()
-	}
-	trans, err := NewTHttpPostClient("http://" + addr.String())
-	if err != nil {
-		l.Close()
-		t.Fatalf("Unable to connect to %s: %s", addr.String(), err)
-	}
-	TransportHeaderTest(t, trans, trans)
-}
-
-func TestHttpCustomClient(t *testing.T) {
-	l, addr := HttpClientSetupForTest(t)
-	if l != nil {
-		defer l.Close()
-	}
-
-	httpTransport := &customHttpTransport{}
-
-	trans, err := NewTHttpPostClientWithOptions("http://"+addr.String(), THttpClientOptions{
-		Client: &http.Client{
-			Transport: httpTransport,
-		},
-	})
-	if err != nil {
-		l.Close()
-		t.Fatalf("Unable to connect to %s: %s", addr.String(), err)
-	}
-	TransportHeaderTest(t, trans, trans)
-
-	if !httpTransport.hit {
-		t.Fatalf("Custom client was not used")
-	}
-}
-
-func TestHttpCustomClientPackageScope(t *testing.T) {
-	l, addr := HttpClientSetupForTest(t)
-	if l != nil {
-		defer l.Close()
-	}
-	httpTransport := &customHttpTransport{}
-	DefaultHttpClient = &http.Client{
-		Transport: httpTransport,
-	}
-
-	trans, err := NewTHttpPostClient("http://" + addr.String())
-	if err != nil {
-		l.Close()
-		t.Fatalf("Unable to connect to %s: %s", addr.String(), err)
-	}
-	TransportHeaderTest(t, trans, trans)
-
-	if !httpTransport.hit {
-		t.Fatalf("Custom client was not used")
-	}
-}
-
-type customHttpTransport struct {
-	hit bool
-}
-
-func (c *customHttpTransport) RoundTrip(req *http.Request) (*http.Response, error) {
-	c.hit = true
-	return http.DefaultTransport.RoundTrip(req)
-}

vendor/github.com/apache/thrift/lib/go/thrift/http_transport.go

@@ -1,63 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"compress/gzip"
-	"io"
-	"net/http"
-	"strings"
-)
-
-// NewThriftHandlerFunc is a function that create a ready to use Apache Thrift Handler function
-func NewThriftHandlerFunc(processor TProcessor,
-	inPfactory, outPfactory TProtocolFactory) func(w http.ResponseWriter, r *http.Request) {
-
-	return gz(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Add("Content-Type", "application/x-thrift")
-
-		transport := NewStreamTransport(r.Body, w)
-		processor.Process(r.Context(), inPfactory.GetProtocol(transport), outPfactory.GetProtocol(transport))
-	})
-}
-
-// gz transparently compresses the HTTP response if the client supports it.
-func gz(handler http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
-			handler(w, r)
-			return
-		}
-		w.Header().Set("Content-Encoding", "gzip")
-		gz := gzip.NewWriter(w)
-		defer gz.Close()
-		gzw := gzipResponseWriter{Writer: gz, ResponseWriter: w}
-		handler(gzw, r)
-	}
-}
-
-type gzipResponseWriter struct {
-	io.Writer
-	http.ResponseWriter
-}
-
-func (w gzipResponseWriter) Write(b []byte) (int, error) {
-	return w.Writer.Write(b)
-}

vendor/github.com/apache/thrift/lib/go/thrift/iostream_transport.go

@@ -1,214 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"bufio"
-	"context"
-	"io"
-)
-
-// StreamTransport is a Transport made of an io.Reader and/or an io.Writer
-type StreamTransport struct {
-	io.Reader
-	io.Writer
-	isReadWriter bool
-	closed       bool
-}
-
-type StreamTransportFactory struct {
-	Reader       io.Reader
-	Writer       io.Writer
-	isReadWriter bool
-}
-
-func (p *StreamTransportFactory) GetTransport(trans TTransport) (TTransport, error) {
-	if trans != nil {
-		t, ok := trans.(*StreamTransport)
-		if ok {
-			if t.isReadWriter {
-				return NewStreamTransportRW(t.Reader.(io.ReadWriter)), nil
-			}
-			if t.Reader != nil && t.Writer != nil {
-				return NewStreamTransport(t.Reader, t.Writer), nil
-			}
-			if t.Reader != nil && t.Writer == nil {
-				return NewStreamTransportR(t.Reader), nil
-			}
-			if t.Reader == nil && t.Writer != nil {
-				return NewStreamTransportW(t.Writer), nil
-			}
-			return &StreamTransport{}, nil
-		}
-	}
-	if p.isReadWriter {
-		return NewStreamTransportRW(p.Reader.(io.ReadWriter)), nil
-	}
-	if p.Reader != nil && p.Writer != nil {
-		return NewStreamTransport(p.Reader, p.Writer), nil
-	}
-	if p.Reader != nil && p.Writer == nil {
-		return NewStreamTransportR(p.Reader), nil
-	}
-	if p.Reader == nil && p.Writer != nil {
-		return NewStreamTransportW(p.Writer), nil
-	}
-	return &StreamTransport{}, nil
-}
-
-func NewStreamTransportFactory(reader io.Reader, writer io.Writer, isReadWriter bool) *StreamTransportFactory {
-	return &StreamTransportFactory{Reader: reader, Writer: writer, isReadWriter: isReadWriter}
-}
-
-func NewStreamTransport(r io.Reader, w io.Writer) *StreamTransport {
-	return &StreamTransport{Reader: bufio.NewReader(r), Writer: bufio.NewWriter(w)}
-}
-
-func NewStreamTransportR(r io.Reader) *StreamTransport {
-	return &StreamTransport{Reader: bufio.NewReader(r)}
-}
-
-func NewStreamTransportW(w io.Writer) *StreamTransport {
-	return &StreamTransport{Writer: bufio.NewWriter(w)}
-}
-
-func NewStreamTransportRW(rw io.ReadWriter) *StreamTransport {
-	bufrw := bufio.NewReadWriter(bufio.NewReader(rw), bufio.NewWriter(rw))
-	return &StreamTransport{Reader: bufrw, Writer: bufrw, isReadWriter: true}
-}
-
-func (p *StreamTransport) IsOpen() bool {
-	return !p.closed
-}
-
-// implicitly opened on creation, can't be reopened once closed
-func (p *StreamTransport) Open() error {
-	if !p.closed {
-		return NewTTransportException(ALREADY_OPEN, "StreamTransport already open.")
-	} else {
-		return NewTTransportException(NOT_OPEN, "cannot reopen StreamTransport.")
-	}
-}
-
-// Closes both the input and output streams.
-func (p *StreamTransport) Close() error {
-	if p.closed {
-		return NewTTransportException(NOT_OPEN, "StreamTransport already closed.")
-	}
-	p.closed = true
-	closedReader := false
-	if p.Reader != nil {
-		c, ok := p.Reader.(io.Closer)
-		if ok {
-			e := c.Close()
-			closedReader = true
-			if e != nil {
-				return e
-			}
-		}
-		p.Reader = nil
-	}
-	if p.Writer != nil && (!closedReader || !p.isReadWriter) {
-		c, ok := p.Writer.(io.Closer)
-		if ok {
-			e := c.Close()
-			if e != nil {
-				return e
-			}
-		}
-		p.Writer = nil
-	}
-	return nil
-}
-
-// Flushes the underlying output stream if not null.
-func (p *StreamTransport) Flush(ctx context.Context) error {
-	if p.Writer == nil {
-		return NewTTransportException(NOT_OPEN, "Cannot flush null outputStream")
-	}
-	f, ok := p.Writer.(Flusher)
-	if ok {
-		err := f.Flush()
-		if err != nil {
-			return NewTTransportExceptionFromError(err)
-		}
-	}
-	return nil
-}
-
-func (p *StreamTransport) Read(c []byte) (n int, err error) {
-	n, err = p.Reader.Read(c)
-	if err != nil {
-		err = NewTTransportExceptionFromError(err)
-	}
-	return
-}
-
-func (p *StreamTransport) ReadByte() (c byte, err error) {
-	f, ok := p.Reader.(io.ByteReader)
-	if ok {
-		c, err = f.ReadByte()
-	} else {
-		c, err = readByte(p.Reader)
-	}
-	if err != nil {
-		err = NewTTransportExceptionFromError(err)
-	}
-	return
-}
-
-func (p *StreamTransport) Write(c []byte) (n int, err error) {
-	n, err = p.Writer.Write(c)
-	if err != nil {
-		err = NewTTransportExceptionFromError(err)
-	}
-	return
-}
-
-func (p *StreamTransport) WriteByte(c byte) (err error) {
-	f, ok := p.Writer.(io.ByteWriter)
-	if ok {
-		err = f.WriteByte(c)
-	} else {
-		err = writeByte(p.Writer, c)
-	}
-	if err != nil {
-		err = NewTTransportExceptionFromError(err)
-	}
-	return
-}
-
-func (p *StreamTransport) WriteString(s string) (n int, err error) {
-	f, ok := p.Writer.(stringWriter)
-	if ok {
-		n, err = f.WriteString(s)
-	} else {
-		n, err = p.Writer.Write([]byte(s))
-	}
-	if err != nil {
-		err = NewTTransportExceptionFromError(err)
-	}
-	return
-}
-
-func (p *StreamTransport) RemainingBytes() (num_bytes uint64) {
-	const maxSize = ^uint64(0)
-	return maxSize // the thruth is, we just don't know unless framed is used
-}

vendor/github.com/apache/thrift/lib/go/thrift/iostream_transport_test.go

@@ -1,52 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"bytes"
-	"testing"
-)
-
-func TestStreamTransport(t *testing.T) {
-	trans := NewStreamTransportRW(bytes.NewBuffer(make([]byte, 0, 1024)))
-	TransportTest(t, trans, trans)
-}
-
-func TestStreamTransportOpenClose(t *testing.T) {
-	trans := NewStreamTransportRW(bytes.NewBuffer(make([]byte, 0, 1024)))
-	if !trans.IsOpen() {
-		t.Fatal("StreamTransport should be already open")
-	}
-	if trans.Open() == nil {
-		t.Fatal("StreamTransport should return error when open twice")
-	}
-	if trans.Close() != nil {
-		t.Fatal("StreamTransport should not return error when closing open transport")
-	}
-	if trans.IsOpen() {
-		t.Fatal("StreamTransport should not be open after close")
-	}
-	if trans.Close() == nil {
-		t.Fatal("StreamTransport should return error when closing a non open transport")
-	}
-	if trans.Open() == nil {
-		t.Fatal("StreamTransport should not be able to reopen")
-	}
-}

vendor/github.com/apache/thrift/lib/go/thrift/json_protocol.go

@@ -1,584 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"context"
-	"encoding/base64"
-	"fmt"
-)
-
-const (
-	THRIFT_JSON_PROTOCOL_VERSION = 1
-)
-
-// for references to _ParseContext see tsimplejson_protocol.go
-
-// JSON protocol implementation for thrift.
-//
-// This protocol produces/consumes a simple output format
-// suitable for parsing by scripting languages.  It should not be
-// confused with the full-featured TJSONProtocol.
-//
-type TJSONProtocol struct {
-	*TSimpleJSONProtocol
-}
-
-// Constructor
-func NewTJSONProtocol(t TTransport) *TJSONProtocol {
-	v := &TJSONProtocol{TSimpleJSONProtocol: NewTSimpleJSONProtocol(t)}
-	v.parseContextStack = append(v.parseContextStack, int(_CONTEXT_IN_TOPLEVEL))
-	v.dumpContext = append(v.dumpContext, int(_CONTEXT_IN_TOPLEVEL))
-	return v
-}
-
-// Factory
-type TJSONProtocolFactory struct{}
-
-func (p *TJSONProtocolFactory) GetProtocol(trans TTransport) TProtocol {
-	return NewTJSONProtocol(trans)
-}
-
-func NewTJSONProtocolFactory() *TJSONProtocolFactory {
-	return &TJSONProtocolFactory{}
-}
-
-func (p *TJSONProtocol) WriteMessageBegin(name string, typeId TMessageType, seqId int32) error {
-	p.resetContextStack() // THRIFT-3735
-	if e := p.OutputListBegin(); e != nil {
-		return e
-	}
-	if e := p.WriteI32(THRIFT_JSON_PROTOCOL_VERSION); e != nil {
-		return e
-	}
-	if e := p.WriteString(name); e != nil {
-		return e
-	}
-	if e := p.WriteByte(int8(typeId)); e != nil {
-		return e
-	}
-	if e := p.WriteI32(seqId); e != nil {
-		return e
-	}
-	return nil
-}
-
-func (p *TJSONProtocol) WriteMessageEnd() error {
-	return p.OutputListEnd()
-}
-
-func (p *TJSONProtocol) WriteStructBegin(name string) error {
-	if e := p.OutputObjectBegin(); e != nil {
-		return e
-	}
-	return nil
-}
-
-func (p *TJSONProtocol) WriteStructEnd() error {
-	return p.OutputObjectEnd()
-}
-
-func (p *TJSONProtocol) WriteFieldBegin(name string, typeId TType, id int16) error {
-	if e := p.WriteI16(id); e != nil {
-		return e
-	}
-	if e := p.OutputObjectBegin(); e != nil {
-		return e
-	}
-	s, e1 := p.TypeIdToString(typeId)
-	if e1 != nil {
-		return e1
-	}
-	if e := p.WriteString(s); e != nil {
-		return e
-	}
-	return nil
-}
-
-func (p *TJSONProtocol) WriteFieldEnd() error {
-	return p.OutputObjectEnd()
-}
-
-func (p *TJSONProtocol) WriteFieldStop() error { return nil }
-
-func (p *TJSONProtocol) WriteMapBegin(keyType TType, valueType TType, size int) error {
-	if e := p.OutputListBegin(); e != nil {
-		return e
-	}
-	s, e1 := p.TypeIdToString(keyType)
-	if e1 != nil {
-		return e1
-	}
-	if e := p.WriteString(s); e != nil {
-		return e
-	}
-	s, e1 = p.TypeIdToString(valueType)
-	if e1 != nil {
-		return e1
-	}
-	if e := p.WriteString(s); e != nil {
-		return e
-	}
-	if e := p.WriteI64(int64(size)); e != nil {
-		return e
-	}
-	return p.OutputObjectBegin()
-}
-
-func (p *TJSONProtocol) WriteMapEnd() error {
-	if e := p.OutputObjectEnd(); e != nil {
-		return e
-	}
-	return p.OutputListEnd()
-}
-
-func (p *TJSONProtocol) WriteListBegin(elemType TType, size int) error {
-	return p.OutputElemListBegin(elemType, size)
-}
-
-func (p *TJSONProtocol) WriteListEnd() error {
-	return p.OutputListEnd()
-}
-
-func (p *TJSONProtocol) WriteSetBegin(elemType TType, size int) error {
-	return p.OutputElemListBegin(elemType, size)
-}
-
-func (p *TJSONProtocol) WriteSetEnd() error {
-	return p.OutputListEnd()
-}
-
-func (p *TJSONProtocol) WriteBool(b bool) error {
-	if b {
-		return p.WriteI32(1)
-	}
-	return p.WriteI32(0)
-}
-
-func (p *TJSONProtocol) WriteByte(b int8) error {
-	return p.WriteI32(int32(b))
-}
-
-func (p *TJSONProtocol) WriteI16(v int16) error {
-	return p.WriteI32(int32(v))
-}
-
-func (p *TJSONProtocol) WriteI32(v int32) error {
-	return p.OutputI64(int64(v))
-}
-
-func (p *TJSONProtocol) WriteI64(v int64) error {
-	return p.OutputI64(int64(v))
-}
-
-func (p *TJSONProtocol) WriteDouble(v float64) error {
-	return p.OutputF64(v)
-}
-
-func (p *TJSONProtocol) WriteString(v string) error {
-	return p.OutputString(v)
-}
-
-func (p *TJSONProtocol) WriteBinary(v []byte) error {
-	// JSON library only takes in a string,
-	// not an arbitrary byte array, to ensure bytes are transmitted
-	// efficiently we must convert this into a valid JSON string
-	// therefore we use base64 encoding to avoid excessive escaping/quoting
-	if e := p.OutputPreValue(); e != nil {
-		return e
-	}
-	if _, e := p.write(JSON_QUOTE_BYTES); e != nil {
-		return NewTProtocolException(e)
-	}
-	writer := base64.NewEncoder(base64.StdEncoding, p.writer)
-	if _, e := writer.Write(v); e != nil {
-		p.writer.Reset(p.trans) // THRIFT-3735
-		return NewTProtocolException(e)
-	}
-	if e := writer.Close(); e != nil {
-		return NewTProtocolException(e)
-	}
-	if _, e := p.write(JSON_QUOTE_BYTES); e != nil {
-		return NewTProtocolException(e)
-	}
-	return p.OutputPostValue()
-}
-
-// Reading methods.
-func (p *TJSONProtocol) ReadMessageBegin() (name string, typeId TMessageType, seqId int32, err error) {
-	p.resetContextStack() // THRIFT-3735
-	if isNull, err := p.ParseListBegin(); isNull || err != nil {
-		return name, typeId, seqId, err
-	}
-	version, err := p.ReadI32()
-	if err != nil {
-		return name, typeId, seqId, err
-	}
-	if version != THRIFT_JSON_PROTOCOL_VERSION {
-		e := fmt.Errorf("Unknown Protocol version %d, expected version %d", version, THRIFT_JSON_PROTOCOL_VERSION)
-		return name, typeId, seqId, NewTProtocolExceptionWithType(INVALID_DATA, e)
-
-	}
-	if name, err = p.ReadString(); err != nil {
-		return name, typeId, seqId, err
-	}
-	bTypeId, err := p.ReadByte()
-	typeId = TMessageType(bTypeId)
-	if err != nil {
-		return name, typeId, seqId, err
-	}
-	if seqId, err = p.ReadI32(); err != nil {
-		return name, typeId, seqId, err
-	}
-	return name, typeId, seqId, nil
-}
-
-func (p *TJSONProtocol) ReadMessageEnd() error {
-	err := p.ParseListEnd()
-	return err
-}
-
-func (p *TJSONProtocol) ReadStructBegin() (name string, err error) {
-	_, err = p.ParseObjectStart()
-	return "", err
-}
-
-func (p *TJSONProtocol) ReadStructEnd() error {
-	return p.ParseObjectEnd()
-}
-
-func (p *TJSONProtocol) ReadFieldBegin() (string, TType, int16, error) {
-	b, _ := p.reader.Peek(1)
-	if len(b) < 1 || b[0] == JSON_RBRACE[0] || b[0] == JSON_RBRACKET[0] {
-		return "", STOP, -1, nil
-	}
-	fieldId, err := p.ReadI16()
-	if err != nil {
-		return "", STOP, fieldId, err
-	}
-	if _, err = p.ParseObjectStart(); err != nil {
-		return "", STOP, fieldId, err
-	}
-	sType, err := p.ReadString()
-	if err != nil {
-		return "", STOP, fieldId, err
-	}
-	fType, err := p.StringToTypeId(sType)
-	return "", fType, fieldId, err
-}
-
-func (p *TJSONProtocol) ReadFieldEnd() error {
-	return p.ParseObjectEnd()
-}
-
-func (p *TJSONProtocol) ReadMapBegin() (keyType TType, valueType TType, size int, e error) {
-	if isNull, e := p.ParseListBegin(); isNull || e != nil {
-		return VOID, VOID, 0, e
-	}
-
-	// read keyType
-	sKeyType, e := p.ReadString()
-	if e != nil {
-		return keyType, valueType, size, e
-	}
-	keyType, e = p.StringToTypeId(sKeyType)
-	if e != nil {
-		return keyType, valueType, size, e
-	}
-
-	// read valueType
-	sValueType, e := p.ReadString()
-	if e != nil {
-		return keyType, valueType, size, e
-	}
-	valueType, e = p.StringToTypeId(sValueType)
-	if e != nil {
-		return keyType, valueType, size, e
-	}
-
-	// read size
-	iSize, e := p.ReadI64()
-	if e != nil {
-		return keyType, valueType, size, e
-	}
-	size = int(iSize)
-
-	_, e = p.ParseObjectStart()
-	return keyType, valueType, size, e
-}
-
-func (p *TJSONProtocol) ReadMapEnd() error {
-	e := p.ParseObjectEnd()
-	if e != nil {
-		return e
-	}
-	return p.ParseListEnd()
-}
-
-func (p *TJSONProtocol) ReadListBegin() (elemType TType, size int, e error) {
-	return p.ParseElemListBegin()
-}
-
-func (p *TJSONProtocol) ReadListEnd() error {
-	return p.ParseListEnd()
-}
-
-func (p *TJSONProtocol) ReadSetBegin() (elemType TType, size int, e error) {
-	return p.ParseElemListBegin()
-}
-
-func (p *TJSONProtocol) ReadSetEnd() error {
-	return p.ParseListEnd()
-}
-
-func (p *TJSONProtocol) ReadBool() (bool, error) {
-	value, err := p.ReadI32()
-	return (value != 0), err
-}
-
-func (p *TJSONProtocol) ReadByte() (int8, error) {
-	v, err := p.ReadI64()
-	return int8(v), err
-}
-
-func (p *TJSONProtocol) ReadI16() (int16, error) {
-	v, err := p.ReadI64()
-	return int16(v), err
-}
-
-func (p *TJSONProtocol) ReadI32() (int32, error) {
-	v, err := p.ReadI64()
-	return int32(v), err
-}
-
-func (p *TJSONProtocol) ReadI64() (int64, error) {
-	v, _, err := p.ParseI64()
-	return v, err
-}
-
-func (p *TJSONProtocol) ReadDouble() (float64, error) {
-	v, _, err := p.ParseF64()
-	return v, err
-}
-
-func (p *TJSONProtocol) ReadString() (string, error) {
-	var v string
-	if err := p.ParsePreValue(); err != nil {
-		return v, err
-	}
-	f, _ := p.reader.Peek(1)
-	if len(f) > 0 && f[0] == JSON_QUOTE {
-		p.reader.ReadByte()
-		value, err := p.ParseStringBody()
-		v = value
-		if err != nil {
-			return v, err
-		}
-	} else if len(f) > 0 && f[0] == JSON_NULL[0] {
-		b := make([]byte, len(JSON_NULL))
-		_, err := p.reader.Read(b)
-		if err != nil {
-			return v, NewTProtocolException(err)
-		}
-		if string(b) != string(JSON_NULL) {
-			e := fmt.Errorf("Expected a JSON string, found unquoted data started with %s", string(b))
-			return v, NewTProtocolExceptionWithType(INVALID_DATA, e)
-		}
-	} else {
-		e := fmt.Errorf("Expected a JSON string, found unquoted data started with %s", string(f))
-		return v, NewTProtocolExceptionWithType(INVALID_DATA, e)
-	}
-	return v, p.ParsePostValue()
-}
-
-func (p *TJSONProtocol) ReadBinary() ([]byte, error) {
-	var v []byte
-	if err := p.ParsePreValue(); err != nil {
-		return nil, err
-	}
-	f, _ := p.reader.Peek(1)
-	if len(f) > 0 && f[0] == JSON_QUOTE {
-		p.reader.ReadByte()
-		value, err := p.ParseBase64EncodedBody()
-		v = value
-		if err != nil {
-			return v, err
-		}
-	} else if len(f) > 0 && f[0] == JSON_NULL[0] {
-		b := make([]byte, len(JSON_NULL))
-		_, err := p.reader.Read(b)
-		if err != nil {
-			return v, NewTProtocolException(err)
-		}
-		if string(b) != string(JSON_NULL) {
-			e := fmt.Errorf("Expected a JSON string, found unquoted data started with %s", string(b))
-			return v, NewTProtocolExceptionWithType(INVALID_DATA, e)
-		}
-	} else {
-		e := fmt.Errorf("Expected a JSON string, found unquoted data started with %s", string(f))
-		return v, NewTProtocolExceptionWithType(INVALID_DATA, e)
-	}
-
-	return v, p.ParsePostValue()
-}
-
-func (p *TJSONProtocol) Flush(ctx context.Context) (err error) {
-	err = p.writer.Flush()
-	if err == nil {
-		err = p.trans.Flush(ctx)
-	}
-	return NewTProtocolException(err)
-}
-
-func (p *TJSONProtocol) Skip(fieldType TType) (err error) {
-	return SkipDefaultDepth(p, fieldType)
-}
-
-func (p *TJSONProtocol) Transport() TTransport {
-	return p.trans
-}
-
-func (p *TJSONProtocol) OutputElemListBegin(elemType TType, size int) error {
-	if e := p.OutputListBegin(); e != nil {
-		return e
-	}
-	s, e1 := p.TypeIdToString(elemType)
-	if e1 != nil {
-		return e1
-	}
-	if e := p.WriteString(s); e != nil {
-		return e
-	}
-	if e := p.WriteI64(int64(size)); e != nil {
-		return e
-	}
-	return nil
-}
-
-func (p *TJSONProtocol) ParseElemListBegin() (elemType TType, size int, e error) {
-	if isNull, e := p.ParseListBegin(); isNull || e != nil {
-		return VOID, 0, e
-	}
-	sElemType, err := p.ReadString()
-	if err != nil {
-		return VOID, size, err
-	}
-	elemType, err = p.StringToTypeId(sElemType)
-	if err != nil {
-		return elemType, size, err
-	}
-	nSize, err2 := p.ReadI64()
-	size = int(nSize)
-	return elemType, size, err2
-}
-
-func (p *TJSONProtocol) readElemListBegin() (elemType TType, size int, e error) {
-	if isNull, e := p.ParseListBegin(); isNull || e != nil {
-		return VOID, 0, e
-	}
-	sElemType, err := p.ReadString()
-	if err != nil {
-		return VOID, size, err
-	}
-	elemType, err = p.StringToTypeId(sElemType)
-	if err != nil {
-		return elemType, size, err
-	}
-	nSize, err2 := p.ReadI64()
-	size = int(nSize)
-	return elemType, size, err2
-}
-
-func (p *TJSONProtocol) writeElemListBegin(elemType TType, size int) error {
-	if e := p.OutputListBegin(); e != nil {
-		return e
-	}
-	s, e1 := p.TypeIdToString(elemType)
-	if e1 != nil {
-		return e1
-	}
-	if e := p.OutputString(s); e != nil {
-		return e
-	}
-	if e := p.OutputI64(int64(size)); e != nil {
-		return e
-	}
-	return nil
-}
-
-func (p *TJSONProtocol) TypeIdToString(fieldType TType) (string, error) {
-	switch byte(fieldType) {
-	case BOOL:
-		return "tf", nil
-	case BYTE:
-		return "i8", nil
-	case I16:
-		return "i16", nil
-	case I32:
-		return "i32", nil
-	case I64:
-		return "i64", nil
-	case DOUBLE:
-		return "dbl", nil
-	case STRING:
-		return "str", nil
-	case STRUCT:
-		return "rec", nil
-	case MAP:
-		return "map", nil
-	case SET:
-		return "set", nil
-	case LIST:
-		return "lst", nil
-	}
-
-	e := fmt.Errorf("Unknown fieldType: %d", int(fieldType))
-	return "", NewTProtocolExceptionWithType(INVALID_DATA, e)
-}
-
-func (p *TJSONProtocol) StringToTypeId(fieldType string) (TType, error) {
-	switch fieldType {
-	case "tf":
-		return TType(BOOL), nil
-	case "i8":
-		return TType(BYTE), nil
-	case "i16":
-		return TType(I16), nil
-	case "i32":
-		return TType(I32), nil
-	case "i64":
-		return TType(I64), nil
-	case "dbl":
-		return TType(DOUBLE), nil
-	case "str":
-		return TType(STRING), nil
-	case "rec":
-		return TType(STRUCT), nil
-	case "map":
-		return TType(MAP), nil
-	case "set":
-		return TType(SET), nil
-	case "lst":
-		return TType(LIST), nil
-	}
-
-	e := fmt.Errorf("Unknown type identifier: %s", fieldType)
-	return TType(STOP), NewTProtocolExceptionWithType(INVALID_DATA, e)
-}

vendor/github.com/apache/thrift/lib/go/thrift/json_protocol_test.go

@@ -1,650 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"math"
-	"strconv"
-	"testing"
-)
-
-func TestWriteJSONProtocolBool(t *testing.T) {
-	thetype := "boolean"
-	trans := NewTMemoryBuffer()
-	p := NewTJSONProtocol(trans)
-	for _, value := range BOOL_VALUES {
-		if e := p.WriteBool(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		expected := ""
-		if value {
-			expected = "1"
-		} else {
-			expected = "0"
-		}
-		if s != expected {
-			t.Fatalf("Bad value for %s %v: %s expected", thetype, value, s)
-		}
-		v := -1
-		if err := json.Unmarshal([]byte(s), &v); err != nil || (v != 0) != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadJSONProtocolBool(t *testing.T) {
-	thetype := "boolean"
-	for _, value := range BOOL_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTJSONProtocol(trans)
-		if value {
-			trans.Write([]byte{'1'}) // not JSON_TRUE
-		} else {
-			trans.Write([]byte{'0'}) // not JSON_FALSE
-		}
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadBool()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if v != value {
-			t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-		}
-		vv := -1
-		if err := json.Unmarshal([]byte(s), &vv); err != nil || (vv != 0) != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, vv)
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-
-func TestWriteJSONProtocolByte(t *testing.T) {
-	thetype := "byte"
-	trans := NewTMemoryBuffer()
-	p := NewTJSONProtocol(trans)
-	for _, value := range BYTE_VALUES {
-		if e := p.WriteByte(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		if s != fmt.Sprint(value) {
-			t.Fatalf("Bad value for %s %v: %s", thetype, value, s)
-		}
-		v := int8(0)
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadJSONProtocolByte(t *testing.T) {
-	thetype := "byte"
-	for _, value := range BYTE_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTJSONProtocol(trans)
-		trans.WriteString(strconv.Itoa(int(value)))
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadByte()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if v != value {
-			t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-		}
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-
-func TestWriteJSONProtocolI16(t *testing.T) {
-	thetype := "int16"
-	trans := NewTMemoryBuffer()
-	p := NewTJSONProtocol(trans)
-	for _, value := range INT16_VALUES {
-		if e := p.WriteI16(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		if s != fmt.Sprint(value) {
-			t.Fatalf("Bad value for %s %v: %s", thetype, value, s)
-		}
-		v := int16(0)
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadJSONProtocolI16(t *testing.T) {
-	thetype := "int16"
-	for _, value := range INT16_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTJSONProtocol(trans)
-		trans.WriteString(strconv.Itoa(int(value)))
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadI16()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if v != value {
-			t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-		}
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-
-func TestWriteJSONProtocolI32(t *testing.T) {
-	thetype := "int32"
-	trans := NewTMemoryBuffer()
-	p := NewTJSONProtocol(trans)
-	for _, value := range INT32_VALUES {
-		if e := p.WriteI32(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		if s != fmt.Sprint(value) {
-			t.Fatalf("Bad value for %s %v: %s", thetype, value, s)
-		}
-		v := int32(0)
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadJSONProtocolI32(t *testing.T) {
-	thetype := "int32"
-	for _, value := range INT32_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTJSONProtocol(trans)
-		trans.WriteString(strconv.Itoa(int(value)))
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadI32()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if v != value {
-			t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-		}
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-
-func TestWriteJSONProtocolI64(t *testing.T) {
-	thetype := "int64"
-	trans := NewTMemoryBuffer()
-	p := NewTJSONProtocol(trans)
-	for _, value := range INT64_VALUES {
-		if e := p.WriteI64(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		if s != fmt.Sprint(value) {
-			t.Fatalf("Bad value for %s %v: %s", thetype, value, s)
-		}
-		v := int64(0)
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadJSONProtocolI64(t *testing.T) {
-	thetype := "int64"
-	for _, value := range INT64_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTJSONProtocol(trans)
-		trans.WriteString(strconv.FormatInt(value, 10))
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadI64()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if v != value {
-			t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-		}
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-
-func TestWriteJSONProtocolDouble(t *testing.T) {
-	thetype := "double"
-	trans := NewTMemoryBuffer()
-	p := NewTJSONProtocol(trans)
-	for _, value := range DOUBLE_VALUES {
-		if e := p.WriteDouble(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		if math.IsInf(value, 1) {
-			if s != jsonQuote(JSON_INFINITY) {
-				t.Fatalf("Bad value for %s %v, wrote: %v, expected: %v", thetype, value, s, jsonQuote(JSON_INFINITY))
-			}
-		} else if math.IsInf(value, -1) {
-			if s != jsonQuote(JSON_NEGATIVE_INFINITY) {
-				t.Fatalf("Bad value for %s %v, wrote: %v, expected: %v", thetype, value, s, jsonQuote(JSON_NEGATIVE_INFINITY))
-			}
-		} else if math.IsNaN(value) {
-			if s != jsonQuote(JSON_NAN) {
-				t.Fatalf("Bad value for %s %v, wrote: %v, expected: %v", thetype, value, s, jsonQuote(JSON_NAN))
-			}
-		} else {
-			if s != fmt.Sprint(value) {
-				t.Fatalf("Bad value for %s %v: %s", thetype, value, s)
-			}
-			v := float64(0)
-			if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-				t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-			}
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadJSONProtocolDouble(t *testing.T) {
-	thetype := "double"
-	for _, value := range DOUBLE_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTJSONProtocol(trans)
-		n := NewNumericFromDouble(value)
-		trans.WriteString(n.String())
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadDouble()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if math.IsInf(value, 1) {
-			if !math.IsInf(v, 1) {
-				t.Fatalf("Bad value for %s %v, wrote: %v, received: %v", thetype, value, s, v)
-			}
-		} else if math.IsInf(value, -1) {
-			if !math.IsInf(v, -1) {
-				t.Fatalf("Bad value for %s %v, wrote: %v, received: %v", thetype, value, s, v)
-			}
-		} else if math.IsNaN(value) {
-			if !math.IsNaN(v) {
-				t.Fatalf("Bad value for %s %v, wrote: %v, received: %v", thetype, value, s, v)
-			}
-		} else {
-			if v != value {
-				t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-			}
-			if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-				t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-			}
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-
-func TestWriteJSONProtocolString(t *testing.T) {
-	thetype := "string"
-	trans := NewTMemoryBuffer()
-	p := NewTJSONProtocol(trans)
-	for _, value := range STRING_VALUES {
-		if e := p.WriteString(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		if s[0] != '"' || s[len(s)-1] != '"' {
-			t.Fatalf("Bad value for %s '%v', wrote '%v', expected: %v", thetype, value, s, fmt.Sprint("\"", value, "\""))
-		}
-		v := new(string)
-		if err := json.Unmarshal([]byte(s), v); err != nil || *v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, *v)
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadJSONProtocolString(t *testing.T) {
-	thetype := "string"
-	for _, value := range STRING_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTJSONProtocol(trans)
-		trans.WriteString(jsonQuote(value))
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadString()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if v != value {
-			t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-		}
-		v1 := new(string)
-		if err := json.Unmarshal([]byte(s), v1); err != nil || *v1 != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, *v1)
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-
-func TestWriteJSONProtocolBinary(t *testing.T) {
-	thetype := "binary"
-	value := protocol_bdata
-	b64value := make([]byte, base64.StdEncoding.EncodedLen(len(protocol_bdata)))
-	base64.StdEncoding.Encode(b64value, value)
-	b64String := string(b64value)
-	trans := NewTMemoryBuffer()
-	p := NewTJSONProtocol(trans)
-	if e := p.WriteBinary(value); e != nil {
-		t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-	}
-	if e := p.Flush(context.Background()); e != nil {
-		t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-	}
-	s := trans.String()
-	expectedString := fmt.Sprint("\"", b64String, "\"")
-	if s != expectedString {
-		t.Fatalf("Bad value for %s %v\n  wrote:  \"%v\"\nexpected: \"%v\"", thetype, value, s, expectedString)
-	}
-	v1, err := p.ReadBinary()
-	if err != nil {
-		t.Fatalf("Unable to read binary: %s", err.Error())
-	}
-	if len(v1) != len(value) {
-		t.Fatalf("Invalid value for binary\nexpected: \"%v\"\n   read: \"%v\"", value, v1)
-	}
-	for k, v := range value {
-		if v1[k] != v {
-			t.Fatalf("Invalid value for binary at %v\nexpected: \"%v\"\n   read: \"%v\"", k, v, v1[k])
-		}
-	}
-	trans.Close()
-}
-
-func TestReadJSONProtocolBinary(t *testing.T) {
-	thetype := "binary"
-	value := protocol_bdata
-	b64value := make([]byte, base64.StdEncoding.EncodedLen(len(protocol_bdata)))
-	base64.StdEncoding.Encode(b64value, value)
-	b64String := string(b64value)
-	trans := NewTMemoryBuffer()
-	p := NewTJSONProtocol(trans)
-	trans.WriteString(jsonQuote(b64String))
-	trans.Flush(context.Background())
-	s := trans.String()
-	v, e := p.ReadBinary()
-	if e != nil {
-		t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-	}
-	if len(v) != len(value) {
-		t.Fatalf("Bad value for %s value length %v, wrote: %v, received length: %v", thetype, len(value), s, len(v))
-	}
-	for i := 0; i < len(v); i++ {
-		if v[i] != value[i] {
-			t.Fatalf("Bad value for %s at index %d value %v, wrote: %v, received: %v", thetype, i, value[i], s, v[i])
-		}
-	}
-	v1 := new(string)
-	if err := json.Unmarshal([]byte(s), v1); err != nil || *v1 != b64String {
-		t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, *v1)
-	}
-	trans.Reset()
-	trans.Close()
-}
-
-func TestWriteJSONProtocolList(t *testing.T) {
-	thetype := "list"
-	trans := NewTMemoryBuffer()
-	p := NewTJSONProtocol(trans)
-	p.WriteListBegin(TType(DOUBLE), len(DOUBLE_VALUES))
-	for _, value := range DOUBLE_VALUES {
-		if e := p.WriteDouble(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-	}
-	p.WriteListEnd()
-	if e := p.Flush(context.Background()); e != nil {
-		t.Fatalf("Unable to write %s due to error flushing: %s", thetype, e.Error())
-	}
-	str := trans.String()
-	str1 := new([]interface{})
-	err := json.Unmarshal([]byte(str), str1)
-	if err != nil {
-		t.Fatalf("Unable to decode %s, wrote: %s", thetype, str)
-	}
-	l := *str1
-	if len(l) < 2 {
-		t.Fatalf("List must be at least of length two to include metadata")
-	}
-	if l[0] != "dbl" {
-		t.Fatal("Invalid type for list, expected: ", STRING, ", but was: ", l[0])
-	}
-	if int(l[1].(float64)) != len(DOUBLE_VALUES) {
-		t.Fatal("Invalid length for list, expected: ", len(DOUBLE_VALUES), ", but was: ", l[1])
-	}
-	for k, value := range DOUBLE_VALUES {
-		s := l[k+2]
-		if math.IsInf(value, 1) {
-			if s.(string) != JSON_INFINITY {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %q, expected: %q, originally wrote: %q", thetype, k, value, s, jsonQuote(JSON_INFINITY), str)
-			}
-		} else if math.IsInf(value, 0) {
-			if s.(string) != JSON_NEGATIVE_INFINITY {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %q, expected: %q, originally wrote: %q", thetype, k, value, s, jsonQuote(JSON_NEGATIVE_INFINITY), str)
-			}
-		} else if math.IsNaN(value) {
-			if s.(string) != JSON_NAN {
-				t.Fatalf("Bad value for %s at index %v  %v, wrote: %q, expected: %q, originally wrote: %q", thetype, k, value, s, jsonQuote(JSON_NAN), str)
-			}
-		} else {
-			if s.(float64) != value {
-				t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s'", thetype, value, s)
-			}
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestWriteJSONProtocolSet(t *testing.T) {
-	thetype := "set"
-	trans := NewTMemoryBuffer()
-	p := NewTJSONProtocol(trans)
-	p.WriteSetBegin(TType(DOUBLE), len(DOUBLE_VALUES))
-	for _, value := range DOUBLE_VALUES {
-		if e := p.WriteDouble(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-	}
-	p.WriteSetEnd()
-	if e := p.Flush(context.Background()); e != nil {
-		t.Fatalf("Unable to write %s due to error flushing: %s", thetype, e.Error())
-	}
-	str := trans.String()
-	str1 := new([]interface{})
-	err := json.Unmarshal([]byte(str), str1)
-	if err != nil {
-		t.Fatalf("Unable to decode %s, wrote: %s", thetype, str)
-	}
-	l := *str1
-	if len(l) < 2 {
-		t.Fatalf("Set must be at least of length two to include metadata")
-	}
-	if l[0] != "dbl" {
-		t.Fatal("Invalid type for set, expected: ", DOUBLE, ", but was: ", l[0])
-	}
-	if int(l[1].(float64)) != len(DOUBLE_VALUES) {
-		t.Fatal("Invalid length for set, expected: ", len(DOUBLE_VALUES), ", but was: ", l[1])
-	}
-	for k, value := range DOUBLE_VALUES {
-		s := l[k+2]
-		if math.IsInf(value, 1) {
-			if s.(string) != JSON_INFINITY {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %q, expected: %q, originally wrote: %q", thetype, k, value, s, jsonQuote(JSON_INFINITY), str)
-			}
-		} else if math.IsInf(value, 0) {
-			if s.(string) != JSON_NEGATIVE_INFINITY {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %q, expected: %q, originally wrote: %q", thetype, k, value, s, jsonQuote(JSON_NEGATIVE_INFINITY), str)
-			}
-		} else if math.IsNaN(value) {
-			if s.(string) != JSON_NAN {
-				t.Fatalf("Bad value for %s at index %v  %v, wrote: %q, expected: %q, originally wrote: %q", thetype, k, value, s, jsonQuote(JSON_NAN), str)
-			}
-		} else {
-			if s.(float64) != value {
-				t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s'", thetype, value, s)
-			}
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestWriteJSONProtocolMap(t *testing.T) {
-	thetype := "map"
-	trans := NewTMemoryBuffer()
-	p := NewTJSONProtocol(trans)
-	p.WriteMapBegin(TType(I32), TType(DOUBLE), len(DOUBLE_VALUES))
-	for k, value := range DOUBLE_VALUES {
-		if e := p.WriteI32(int32(k)); e != nil {
-			t.Fatalf("Unable to write %s key int32 value %v due to error: %s", thetype, k, e.Error())
-		}
-		if e := p.WriteDouble(value); e != nil {
-			t.Fatalf("Unable to write %s value float64 value %v due to error: %s", thetype, value, e.Error())
-		}
-	}
-	p.WriteMapEnd()
-	if e := p.Flush(context.Background()); e != nil {
-		t.Fatalf("Unable to write %s due to error flushing: %s", thetype, e.Error())
-	}
-	str := trans.String()
-	if str[0] != '[' || str[len(str)-1] != ']' {
-		t.Fatalf("Bad value for %s, wrote: %v, in go: %v", thetype, str, DOUBLE_VALUES)
-	}
-	expectedKeyType, expectedValueType, expectedSize, err := p.ReadMapBegin()
-	if err != nil {
-		t.Fatalf("Error while reading map begin: %s", err.Error())
-	}
-	if expectedKeyType != I32 {
-		t.Fatal("Expected map key type ", I32, ", but was ", expectedKeyType)
-	}
-	if expectedValueType != DOUBLE {
-		t.Fatal("Expected map value type ", DOUBLE, ", but was ", expectedValueType)
-	}
-	if expectedSize != len(DOUBLE_VALUES) {
-		t.Fatal("Expected map size of ", len(DOUBLE_VALUES), ", but was ", expectedSize)
-	}
-	for k, value := range DOUBLE_VALUES {
-		ik, err := p.ReadI32()
-		if err != nil {
-			t.Fatalf("Bad key for %s index %v, wrote: %v, expected: %v, error: %s", thetype, k, ik, string(k), err.Error())
-		}
-		if int(ik) != k {
-			t.Fatalf("Bad key for %s index %v, wrote: %v, expected: %v", thetype, k, ik, k)
-		}
-		dv, err := p.ReadDouble()
-		if err != nil {
-			t.Fatalf("Bad value for %s index %v, wrote: %v, expected: %v, error: %s", thetype, k, dv, value, err.Error())
-		}
-		s := strconv.FormatFloat(dv, 'g', 10, 64)
-		if math.IsInf(value, 1) {
-			if !math.IsInf(dv, 1) {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %v, expected: %v", thetype, k, value, s, jsonQuote(JSON_INFINITY))
-			}
-		} else if math.IsInf(value, 0) {
-			if !math.IsInf(dv, 0) {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %v, expected: %v", thetype, k, value, s, jsonQuote(JSON_NEGATIVE_INFINITY))
-			}
-		} else if math.IsNaN(value) {
-			if !math.IsNaN(dv) {
-				t.Fatalf("Bad value for %s at index %v  %v, wrote: %v, expected: %v", thetype, k, value, s, jsonQuote(JSON_NAN))
-			}
-		} else {
-			expected := strconv.FormatFloat(value, 'g', 10, 64)
-			if s != expected {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %v, expected %v", thetype, k, value, s, expected)
-			}
-			v := float64(0)
-			if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-				t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-			}
-		}
-	}
-	err = p.ReadMapEnd()
-	if err != nil {
-		t.Fatalf("Error while reading map end: %s", err.Error())
-	}
-	trans.Close()
-}

vendor/github.com/apache/thrift/lib/go/thrift/lowlevel_benchmarks_test.go

@@ -1,540 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"bytes"
-	"testing"
-)
-
-var binaryProtoF = NewTBinaryProtocolFactoryDefault()
-var compactProtoF = NewTCompactProtocolFactory()
-
-var buf = bytes.NewBuffer(make([]byte, 0, 1024))
-
-var tfv = []TTransportFactory{
-	NewTMemoryBufferTransportFactory(1024),
-	NewStreamTransportFactory(buf, buf, true),
-	NewTFramedTransportFactory(NewTMemoryBufferTransportFactory(1024)),
-}
-
-func BenchmarkBinaryBool_0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteBool(b, p, trans)
-	}
-}
-
-func BenchmarkBinaryByte_0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteByte(b, p, trans)
-	}
-}
-
-func BenchmarkBinaryI16_0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI16(b, p, trans)
-	}
-}
-
-func BenchmarkBinaryI32_0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI32(b, p, trans)
-	}
-}
-func BenchmarkBinaryI64_0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI64(b, p, trans)
-	}
-}
-func BenchmarkBinaryDouble_0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteDouble(b, p, trans)
-	}
-}
-func BenchmarkBinaryString_0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteString(b, p, trans)
-	}
-}
-func BenchmarkBinaryBinary_0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteBinary(b, p, trans)
-	}
-}
-
-func BenchmarkBinaryBool_1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteBool(b, p, trans)
-	}
-}
-
-func BenchmarkBinaryByte_1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteByte(b, p, trans)
-	}
-}
-
-func BenchmarkBinaryI16_1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI16(b, p, trans)
-	}
-}
-
-func BenchmarkBinaryI32_1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI32(b, p, trans)
-	}
-}
-func BenchmarkBinaryI64_1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI64(b, p, trans)
-	}
-}
-func BenchmarkBinaryDouble_1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteDouble(b, p, trans)
-	}
-}
-func BenchmarkBinaryString_1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteString(b, p, trans)
-	}
-}
-func BenchmarkBinaryBinary_1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteBinary(b, p, trans)
-	}
-}
-
-func BenchmarkBinaryBool_2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteBool(b, p, trans)
-	}
-}
-
-func BenchmarkBinaryByte_2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteByte(b, p, trans)
-	}
-}
-
-func BenchmarkBinaryI16_2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI16(b, p, trans)
-	}
-}
-
-func BenchmarkBinaryI32_2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI32(b, p, trans)
-	}
-}
-func BenchmarkBinaryI64_2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI64(b, p, trans)
-	}
-}
-func BenchmarkBinaryDouble_2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteDouble(b, p, trans)
-	}
-}
-func BenchmarkBinaryString_2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteString(b, p, trans)
-	}
-}
-func BenchmarkBinaryBinary_2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := binaryProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteBinary(b, p, trans)
-	}
-}
-
-func BenchmarkCompactBool_0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteBool(b, p, trans)
-	}
-}
-
-func BenchmarkCompactByte_0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteByte(b, p, trans)
-	}
-}
-
-func BenchmarkCompactI16_0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI16(b, p, trans)
-	}
-}
-
-func BenchmarkCompactI32_0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI32(b, p, trans)
-	}
-}
-func BenchmarkCompactI64_0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI64(b, p, trans)
-	}
-}
-func BenchmarkCompactDouble0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteDouble(b, p, trans)
-	}
-}
-func BenchmarkCompactString0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteString(b, p, trans)
-	}
-}
-func BenchmarkCompactBinary0(b *testing.B) {
-	trans, err := tfv[0].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteBinary(b, p, trans)
-	}
-}
-
-func BenchmarkCompactBool_1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteBool(b, p, trans)
-	}
-}
-
-func BenchmarkCompactByte_1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteByte(b, p, trans)
-	}
-}
-
-func BenchmarkCompactI16_1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI16(b, p, trans)
-	}
-}
-
-func BenchmarkCompactI32_1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI32(b, p, trans)
-	}
-}
-func BenchmarkCompactI64_1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI64(b, p, trans)
-	}
-}
-func BenchmarkCompactDouble1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteDouble(b, p, trans)
-	}
-}
-func BenchmarkCompactString1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteString(b, p, trans)
-	}
-}
-func BenchmarkCompactBinary1(b *testing.B) {
-	trans, err := tfv[1].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteBinary(b, p, trans)
-	}
-}
-
-func BenchmarkCompactBool_2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteBool(b, p, trans)
-	}
-}
-
-func BenchmarkCompactByte_2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteByte(b, p, trans)
-	}
-}
-
-func BenchmarkCompactI16_2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI16(b, p, trans)
-	}
-}
-
-func BenchmarkCompactI32_2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI32(b, p, trans)
-	}
-}
-func BenchmarkCompactI64_2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteI64(b, p, trans)
-	}
-}
-func BenchmarkCompactDouble2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteDouble(b, p, trans)
-	}
-}
-func BenchmarkCompactString2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteString(b, p, trans)
-	}
-}
-func BenchmarkCompactBinary2(b *testing.B) {
-	trans, err := tfv[2].GetTransport(nil)
-	if err != nil {
-		b.Fatal(err)
-	}
-	p := compactProtoF.GetProtocol(trans)
-	for i := 0; i < b.N; i++ {
-		ReadWriteBinary(b, p, trans)
-	}
-}

vendor/github.com/apache/thrift/lib/go/thrift/memory_buffer.go

@@ -1,80 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"bytes"
-	"context"
-)
-
-// Memory buffer-based implementation of the TTransport interface.
-type TMemoryBuffer struct {
-	*bytes.Buffer
-	size int
-}
-
-type TMemoryBufferTransportFactory struct {
-	size int
-}
-
-func (p *TMemoryBufferTransportFactory) GetTransport(trans TTransport) (TTransport, error) {
-	if trans != nil {
-		t, ok := trans.(*TMemoryBuffer)
-		if ok && t.size > 0 {
-			return NewTMemoryBufferLen(t.size), nil
-		}
-	}
-	return NewTMemoryBufferLen(p.size), nil
-}
-
-func NewTMemoryBufferTransportFactory(size int) *TMemoryBufferTransportFactory {
-	return &TMemoryBufferTransportFactory{size: size}
-}
-
-func NewTMemoryBuffer() *TMemoryBuffer {
-	return &TMemoryBuffer{Buffer: &bytes.Buffer{}, size: 0}
-}
-
-func NewTMemoryBufferLen(size int) *TMemoryBuffer {
-	buf := make([]byte, 0, size)
-	return &TMemoryBuffer{Buffer: bytes.NewBuffer(buf), size: size}
-}
-
-func (p *TMemoryBuffer) IsOpen() bool {
-	return true
-}
-
-func (p *TMemoryBuffer) Open() error {
-	return nil
-}
-
-func (p *TMemoryBuffer) Close() error {
-	p.Buffer.Reset()
-	return nil
-}
-
-// Flushing a memory buffer is a no-op
-func (p *TMemoryBuffer) Flush(ctx context.Context) error {
-	return nil
-}
-
-func (p *TMemoryBuffer) RemainingBytes() (num_bytes uint64) {
-	return uint64(p.Buffer.Len())
-}

vendor/github.com/apache/thrift/lib/go/thrift/memory_buffer_test.go

@@ -1,29 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"testing"
-)
-
-func TestMemoryBuffer(t *testing.T) {
-	trans := NewTMemoryBufferLen(1024)
-	TransportTest(t, trans, trans)
-}

vendor/github.com/apache/thrift/lib/go/thrift/messagetype.go

@@ -1,31 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-// Message type constants in the Thrift protocol.
-type TMessageType int32
-
-const (
-	INVALID_TMESSAGE_TYPE TMessageType = 0
-	CALL                  TMessageType = 1
-	REPLY                 TMessageType = 2
-	EXCEPTION             TMessageType = 3
-	ONEWAY                TMessageType = 4
-)

vendor/github.com/apache/thrift/lib/go/thrift/multiplexed_protocol.go

@@ -1,170 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"context"
-	"fmt"
-	"strings"
-)
-
-/*
-TMultiplexedProtocol is a protocol-independent concrete decorator
-that allows a Thrift client to communicate with a multiplexing Thrift server,
-by prepending the service name to the function name during function calls.
-
-NOTE: THIS IS NOT USED BY SERVERS.  On the server, use TMultiplexedProcessor to handle request
-from a multiplexing client.
-
-This example uses a single socket transport to invoke two services:
-
-socket := thrift.NewTSocketFromAddrTimeout(addr, TIMEOUT)
-transport := thrift.NewTFramedTransport(socket)
-protocol := thrift.NewTBinaryProtocolTransport(transport)
-
-mp := thrift.NewTMultiplexedProtocol(protocol, "Calculator")
-service := Calculator.NewCalculatorClient(mp)
-
-mp2 := thrift.NewTMultiplexedProtocol(protocol, "WeatherReport")
-service2 := WeatherReport.NewWeatherReportClient(mp2)
-
-err := transport.Open()
-if err != nil {
-	t.Fatal("Unable to open client socket", err)
-}
-
-fmt.Println(service.Add(2,2))
-fmt.Println(service2.GetTemperature())
-*/
-
-type TMultiplexedProtocol struct {
-	TProtocol
-	serviceName string
-}
-
-const MULTIPLEXED_SEPARATOR = ":"
-
-func NewTMultiplexedProtocol(protocol TProtocol, serviceName string) *TMultiplexedProtocol {
-	return &TMultiplexedProtocol{
-		TProtocol:   protocol,
-		serviceName: serviceName,
-	}
-}
-
-func (t *TMultiplexedProtocol) WriteMessageBegin(name string, typeId TMessageType, seqid int32) error {
-	if typeId == CALL || typeId == ONEWAY {
-		return t.TProtocol.WriteMessageBegin(t.serviceName+MULTIPLEXED_SEPARATOR+name, typeId, seqid)
-	} else {
-		return t.TProtocol.WriteMessageBegin(name, typeId, seqid)
-	}
-}
-
-/*
-TMultiplexedProcessor is a TProcessor allowing
-a single TServer to provide multiple services.
-
-To do so, you instantiate the processor and then register additional
-processors with it, as shown in the following example:
-
-var processor = thrift.NewTMultiplexedProcessor()
-
-firstProcessor :=
-processor.RegisterProcessor("FirstService", firstProcessor)
-
-processor.registerProcessor(
-  "Calculator",
-  Calculator.NewCalculatorProcessor(&CalculatorHandler{}),
-)
-
-processor.registerProcessor(
-  "WeatherReport",
-  WeatherReport.NewWeatherReportProcessor(&WeatherReportHandler{}),
-)
-
-serverTransport, err := thrift.NewTServerSocketTimeout(addr, TIMEOUT)
-if err != nil {
-  t.Fatal("Unable to create server socket", err)
-}
-server := thrift.NewTSimpleServer2(processor, serverTransport)
-server.Serve();
-*/
-
-type TMultiplexedProcessor struct {
-	serviceProcessorMap map[string]TProcessor
-	DefaultProcessor    TProcessor
-}
-
-func NewTMultiplexedProcessor() *TMultiplexedProcessor {
-	return &TMultiplexedProcessor{
-		serviceProcessorMap: make(map[string]TProcessor),
-	}
-}
-
-func (t *TMultiplexedProcessor) RegisterDefault(processor TProcessor) {
-	t.DefaultProcessor = processor
-}
-
-func (t *TMultiplexedProcessor) RegisterProcessor(name string, processor TProcessor) {
-	if t.serviceProcessorMap == nil {
-		t.serviceProcessorMap = make(map[string]TProcessor)
-	}
-	t.serviceProcessorMap[name] = processor
-}
-
-func (t *TMultiplexedProcessor) Process(ctx context.Context, in, out TProtocol) (bool, TException) {
-	name, typeId, seqid, err := in.ReadMessageBegin()
-	if err != nil {
-		return false, err
-	}
-	if typeId != CALL && typeId != ONEWAY {
-		return false, fmt.Errorf("Unexpected message type %v", typeId)
-	}
-	//extract the service name
-	v := strings.SplitN(name, MULTIPLEXED_SEPARATOR, 2)
-	if len(v) != 2 {
-		if t.DefaultProcessor != nil {
-			smb := NewStoredMessageProtocol(in, name, typeId, seqid)
-			return t.DefaultProcessor.Process(ctx, smb, out)
-		}
-		return false, fmt.Errorf("Service name not found in message name: %s.  Did you forget to use a TMultiplexProtocol in your client?", name)
-	}
-	actualProcessor, ok := t.serviceProcessorMap[v[0]]
-	if !ok {
-		return false, fmt.Errorf("Service name not found: %s.  Did you forget to call registerProcessor()?", v[0])
-	}
-	smb := NewStoredMessageProtocol(in, v[1], typeId, seqid)
-	return actualProcessor.Process(ctx, smb, out)
-}
-
-//Protocol that use stored message for ReadMessageBegin
-type storedMessageProtocol struct {
-	TProtocol
-	name   string
-	typeId TMessageType
-	seqid  int32
-}
-
-func NewStoredMessageProtocol(protocol TProtocol, name string, typeId TMessageType, seqid int32) *storedMessageProtocol {
-	return &storedMessageProtocol{protocol, name, typeId, seqid}
-}
-
-func (s *storedMessageProtocol) ReadMessageBegin() (name string, typeId TMessageType, seqid int32, err error) {
-	return s.name, s.typeId, s.seqid, nil
-}

vendor/github.com/apache/thrift/lib/go/thrift/numeric.go

@@ -1,164 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"math"
-	"strconv"
-)
-
-type Numeric interface {
-	Int64() int64
-	Int32() int32
-	Int16() int16
-	Byte() byte
-	Int() int
-	Float64() float64
-	Float32() float32
-	String() string
-	isNull() bool
-}
-
-type numeric struct {
-	iValue int64
-	dValue float64
-	sValue string
-	isNil  bool
-}
-
-var (
-	INFINITY          Numeric
-	NEGATIVE_INFINITY Numeric
-	NAN               Numeric
-	ZERO              Numeric
-	NUMERIC_NULL      Numeric
-)
-
-func NewNumericFromDouble(dValue float64) Numeric {
-	if math.IsInf(dValue, 1) {
-		return INFINITY
-	}
-	if math.IsInf(dValue, -1) {
-		return NEGATIVE_INFINITY
-	}
-	if math.IsNaN(dValue) {
-		return NAN
-	}
-	iValue := int64(dValue)
-	sValue := strconv.FormatFloat(dValue, 'g', 10, 64)
-	isNil := false
-	return &numeric{iValue: iValue, dValue: dValue, sValue: sValue, isNil: isNil}
-}
-
-func NewNumericFromI64(iValue int64) Numeric {
-	dValue := float64(iValue)
-	sValue := string(iValue)
-	isNil := false
-	return &numeric{iValue: iValue, dValue: dValue, sValue: sValue, isNil: isNil}
-}
-
-func NewNumericFromI32(iValue int32) Numeric {
-	dValue := float64(iValue)
-	sValue := string(iValue)
-	isNil := false
-	return &numeric{iValue: int64(iValue), dValue: dValue, sValue: sValue, isNil: isNil}
-}
-
-func NewNumericFromString(sValue string) Numeric {
-	if sValue == INFINITY.String() {
-		return INFINITY
-	}
-	if sValue == NEGATIVE_INFINITY.String() {
-		return NEGATIVE_INFINITY
-	}
-	if sValue == NAN.String() {
-		return NAN
-	}
-	iValue, _ := strconv.ParseInt(sValue, 10, 64)
-	dValue, _ := strconv.ParseFloat(sValue, 64)
-	isNil := len(sValue) == 0
-	return &numeric{iValue: iValue, dValue: dValue, sValue: sValue, isNil: isNil}
-}
-
-func NewNumericFromJSONString(sValue string, isNull bool) Numeric {
-	if isNull {
-		return NewNullNumeric()
-	}
-	if sValue == JSON_INFINITY {
-		return INFINITY
-	}
-	if sValue == JSON_NEGATIVE_INFINITY {
-		return NEGATIVE_INFINITY
-	}
-	if sValue == JSON_NAN {
-		return NAN
-	}
-	iValue, _ := strconv.ParseInt(sValue, 10, 64)
-	dValue, _ := strconv.ParseFloat(sValue, 64)
-	return &numeric{iValue: iValue, dValue: dValue, sValue: sValue, isNil: isNull}
-}
-
-func NewNullNumeric() Numeric {
-	return &numeric{iValue: 0, dValue: 0.0, sValue: "", isNil: true}
-}
-
-func (p *numeric) Int64() int64 {
-	return p.iValue
-}
-
-func (p *numeric) Int32() int32 {
-	return int32(p.iValue)
-}
-
-func (p *numeric) Int16() int16 {
-	return int16(p.iValue)
-}
-
-func (p *numeric) Byte() byte {
-	return byte(p.iValue)
-}
-
-func (p *numeric) Int() int {
-	return int(p.iValue)
-}
-
-func (p *numeric) Float64() float64 {
-	return p.dValue
-}
-
-func (p *numeric) Float32() float32 {
-	return float32(p.dValue)
-}
-
-func (p *numeric) String() string {
-	return p.sValue
-}
-
-func (p *numeric) isNull() bool {
-	return p.isNil
-}
-
-func init() {
-	INFINITY = &numeric{iValue: 0, dValue: math.Inf(1), sValue: "Infinity", isNil: false}
-	NEGATIVE_INFINITY = &numeric{iValue: 0, dValue: math.Inf(-1), sValue: "-Infinity", isNil: false}
-	NAN = &numeric{iValue: 0, dValue: math.NaN(), sValue: "NaN", isNil: false}
-	ZERO = &numeric{iValue: 0, dValue: 0, sValue: "0", isNil: false}
-	NUMERIC_NULL = &numeric{iValue: 0, dValue: 0, sValue: "0", isNil: true}
-}

vendor/github.com/apache/thrift/lib/go/thrift/pointerize.go

@@ -1,50 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-///////////////////////////////////////////////////////////////////////////////
-// This file is home to helpers that convert from various base types to
-// respective pointer types. This is necessary because Go does not permit
-// references to constants, nor can a pointer type to base type be allocated
-// and initialized in a single expression.
-//
-// E.g., this is not allowed:
-//
-//    var ip *int = &5
-//
-// But this *is* allowed:
-//
-//    func IntPtr(i int) *int { return &i }
-//    var ip *int = IntPtr(5)
-//
-// Since pointers to base types are commonplace as [optional] fields in
-// exported thrift structs, we factor such helpers here.
-///////////////////////////////////////////////////////////////////////////////
-
-func Float32Ptr(v float32) *float32 { return &v }
-func Float64Ptr(v float64) *float64 { return &v }
-func IntPtr(v int) *int             { return &v }
-func Int32Ptr(v int32) *int32       { return &v }
-func Int64Ptr(v int64) *int64       { return &v }
-func StringPtr(v string) *string    { return &v }
-func Uint32Ptr(v uint32) *uint32    { return &v }
-func Uint64Ptr(v uint64) *uint64    { return &v }
-func BoolPtr(v bool) *bool          { return &v }
-func ByteSlicePtr(v []byte) *[]byte { return &v }

vendor/github.com/apache/thrift/lib/go/thrift/processor_factory.go

@@ -1,70 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import "context"
-
-// A processor is a generic object which operates upon an input stream and
-// writes to some output stream.
-type TProcessor interface {
-	Process(ctx context.Context, in, out TProtocol) (bool, TException)
-}
-
-type TProcessorFunction interface {
-	Process(ctx context.Context, seqId int32, in, out TProtocol) (bool, TException)
-}
-
-// The default processor factory just returns a singleton
-// instance.
-type TProcessorFactory interface {
-	GetProcessor(trans TTransport) TProcessor
-}
-
-type tProcessorFactory struct {
-	processor TProcessor
-}
-
-func NewTProcessorFactory(p TProcessor) TProcessorFactory {
-	return &tProcessorFactory{processor: p}
-}
-
-func (p *tProcessorFactory) GetProcessor(trans TTransport) TProcessor {
-	return p.processor
-}
-
-/**
- * The default processor factory just returns a singleton
- * instance.
- */
-type TProcessorFunctionFactory interface {
-	GetProcessorFunction(trans TTransport) TProcessorFunction
-}
-
-type tProcessorFunctionFactory struct {
-	processor TProcessorFunction
-}
-
-func NewTProcessorFunctionFactory(p TProcessorFunction) TProcessorFunctionFactory {
-	return &tProcessorFunctionFactory{processor: p}
-}
-
-func (p *tProcessorFunctionFactory) GetProcessorFunction(trans TTransport) TProcessorFunction {
-	return p.processor
-}

vendor/github.com/apache/thrift/lib/go/thrift/protocol.go

@@ -1,179 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"context"
-	"errors"
-	"fmt"
-)
-
-const (
-	VERSION_MASK = 0xffff0000
-	VERSION_1    = 0x80010000
-)
-
-type TProtocol interface {
-	WriteMessageBegin(name string, typeId TMessageType, seqid int32) error
-	WriteMessageEnd() error
-	WriteStructBegin(name string) error
-	WriteStructEnd() error
-	WriteFieldBegin(name string, typeId TType, id int16) error
-	WriteFieldEnd() error
-	WriteFieldStop() error
-	WriteMapBegin(keyType TType, valueType TType, size int) error
-	WriteMapEnd() error
-	WriteListBegin(elemType TType, size int) error
-	WriteListEnd() error
-	WriteSetBegin(elemType TType, size int) error
-	WriteSetEnd() error
-	WriteBool(value bool) error
-	WriteByte(value int8) error
-	WriteI16(value int16) error
-	WriteI32(value int32) error
-	WriteI64(value int64) error
-	WriteDouble(value float64) error
-	WriteString(value string) error
-	WriteBinary(value []byte) error
-
-	ReadMessageBegin() (name string, typeId TMessageType, seqid int32, err error)
-	ReadMessageEnd() error
-	ReadStructBegin() (name string, err error)
-	ReadStructEnd() error
-	ReadFieldBegin() (name string, typeId TType, id int16, err error)
-	ReadFieldEnd() error
-	ReadMapBegin() (keyType TType, valueType TType, size int, err error)
-	ReadMapEnd() error
-	ReadListBegin() (elemType TType, size int, err error)
-	ReadListEnd() error
-	ReadSetBegin() (elemType TType, size int, err error)
-	ReadSetEnd() error
-	ReadBool() (value bool, err error)
-	ReadByte() (value int8, err error)
-	ReadI16() (value int16, err error)
-	ReadI32() (value int32, err error)
-	ReadI64() (value int64, err error)
-	ReadDouble() (value float64, err error)
-	ReadString() (value string, err error)
-	ReadBinary() (value []byte, err error)
-
-	Skip(fieldType TType) (err error)
-	Flush(ctx context.Context) (err error)
-
-	Transport() TTransport
-}
-
-// The maximum recursive depth the skip() function will traverse
-const DEFAULT_RECURSION_DEPTH = 64
-
-// Skips over the next data element from the provided input TProtocol object.
-func SkipDefaultDepth(prot TProtocol, typeId TType) (err error) {
-	return Skip(prot, typeId, DEFAULT_RECURSION_DEPTH)
-}
-
-// Skips over the next data element from the provided input TProtocol object.
-func Skip(self TProtocol, fieldType TType, maxDepth int) (err error) {
-
-	if maxDepth <= 0 {
-		return NewTProtocolExceptionWithType(DEPTH_LIMIT, errors.New("Depth limit exceeded"))
-	}
-
-	switch fieldType {
-	case STOP:
-		return
-	case BOOL:
-		_, err = self.ReadBool()
-		return
-	case BYTE:
-		_, err = self.ReadByte()
-		return
-	case I16:
-		_, err = self.ReadI16()
-		return
-	case I32:
-		_, err = self.ReadI32()
-		return
-	case I64:
-		_, err = self.ReadI64()
-		return
-	case DOUBLE:
-		_, err = self.ReadDouble()
-		return
-	case STRING:
-		_, err = self.ReadString()
-		return
-	case STRUCT:
-		if _, err = self.ReadStructBegin(); err != nil {
-			return err
-		}
-		for {
-			_, typeId, _, _ := self.ReadFieldBegin()
-			if typeId == STOP {
-				break
-			}
-			err := Skip(self, typeId, maxDepth-1)
-			if err != nil {
-				return err
-			}
-			self.ReadFieldEnd()
-		}
-		return self.ReadStructEnd()
-	case MAP:
-		keyType, valueType, size, err := self.ReadMapBegin()
-		if err != nil {
-			return err
-		}
-		for i := 0; i < size; i++ {
-			err := Skip(self, keyType, maxDepth-1)
-			if err != nil {
-				return err
-			}
-			self.Skip(valueType)
-		}
-		return self.ReadMapEnd()
-	case SET:
-		elemType, size, err := self.ReadSetBegin()
-		if err != nil {
-			return err
-		}
-		for i := 0; i < size; i++ {
-			err := Skip(self, elemType, maxDepth-1)
-			if err != nil {
-				return err
-			}
-		}
-		return self.ReadSetEnd()
-	case LIST:
-		elemType, size, err := self.ReadListBegin()
-		if err != nil {
-			return err
-		}
-		for i := 0; i < size; i++ {
-			err := Skip(self, elemType, maxDepth-1)
-			if err != nil {
-				return err
-			}
-		}
-		return self.ReadListEnd()
-	default:
-		return NewTProtocolExceptionWithType(INVALID_DATA, errors.New(fmt.Sprintf("Unknown data type %d", fieldType)))
-	}
-	return nil
-}

vendor/github.com/apache/thrift/lib/go/thrift/protocol_exception.go

@@ -1,77 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"encoding/base64"
-)
-
-// Thrift Protocol exception
-type TProtocolException interface {
-	TException
-	TypeId() int
-}
-
-const (
-	UNKNOWN_PROTOCOL_EXCEPTION = 0
-	INVALID_DATA               = 1
-	NEGATIVE_SIZE              = 2
-	SIZE_LIMIT                 = 3
-	BAD_VERSION                = 4
-	NOT_IMPLEMENTED            = 5
-	DEPTH_LIMIT                = 6
-)
-
-type tProtocolException struct {
-	typeId  int
-	message string
-}
-
-func (p *tProtocolException) TypeId() int {
-	return p.typeId
-}
-
-func (p *tProtocolException) String() string {
-	return p.message
-}
-
-func (p *tProtocolException) Error() string {
-	return p.message
-}
-
-func NewTProtocolException(err error) TProtocolException {
-	if err == nil {
-		return nil
-	}
-	if e, ok := err.(TProtocolException); ok {
-		return e
-	}
-	if _, ok := err.(base64.CorruptInputError); ok {
-		return &tProtocolException{INVALID_DATA, err.Error()}
-	}
-	return &tProtocolException{UNKNOWN_PROTOCOL_EXCEPTION, err.Error()}
-}
-
-func NewTProtocolExceptionWithType(errType int, err error) TProtocolException {
-	if err == nil {
-		return nil
-	}
-	return &tProtocolException{errType, err.Error()}
-}

vendor/github.com/apache/thrift/lib/go/thrift/protocol_factory.go

@@ -1,25 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-// Factory interface for constructing protocol instances.
-type TProtocolFactory interface {
-	GetProtocol(trans TTransport) TProtocol
-}

vendor/github.com/apache/thrift/lib/go/thrift/protocol_test.go

@@ -1,517 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"bytes"
-	"context"
-	"io/ioutil"
-	"math"
-	"net"
-	"net/http"
-	"testing"
-)
-
-const PROTOCOL_BINARY_DATA_SIZE = 155
-
-var (
-	protocol_bdata []byte // test data for writing; same as data
-	BOOL_VALUES    []bool
-	BYTE_VALUES    []int8
-	INT16_VALUES   []int16
-	INT32_VALUES   []int32
-	INT64_VALUES   []int64
-	DOUBLE_VALUES  []float64
-	STRING_VALUES  []string
-)
-
-func init() {
-	protocol_bdata = make([]byte, PROTOCOL_BINARY_DATA_SIZE)
-	for i := 0; i < PROTOCOL_BINARY_DATA_SIZE; i++ {
-		protocol_bdata[i] = byte((i + 'a') % 255)
-	}
-	BOOL_VALUES = []bool{false, true, false, false, true}
-	BYTE_VALUES = []int8{117, 0, 1, 32, 127, -128, -1}
-	INT16_VALUES = []int16{459, 0, 1, -1, -128, 127, 32767, -32768}
-	INT32_VALUES = []int32{459, 0, 1, -1, -128, 127, 32767, 2147483647, -2147483535}
-	INT64_VALUES = []int64{459, 0, 1, -1, -128, 127, 32767, 2147483647, -2147483535, 34359738481, -35184372088719, -9223372036854775808, 9223372036854775807}
-	DOUBLE_VALUES = []float64{459.3, 0.0, -1.0, 1.0, 0.5, 0.3333, 3.14159, 1.537e-38, 1.673e25, 6.02214179e23, -6.02214179e23, INFINITY.Float64(), NEGATIVE_INFINITY.Float64(), NAN.Float64()}
-	STRING_VALUES = []string{"", "a", "st[uf]f", "st,u:ff with spaces", "stuff\twith\nescape\\characters'...\"lots{of}fun</xml>"}
-}
-
-type HTTPEchoServer struct{}
-type HTTPHeaderEchoServer struct{}
-
-func (p *HTTPEchoServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	buf, err := ioutil.ReadAll(req.Body)
-	if err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		w.Write(buf)
-	} else {
-		w.WriteHeader(http.StatusOK)
-		w.Write(buf)
-	}
-}
-
-func (p *HTTPHeaderEchoServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	buf, err := ioutil.ReadAll(req.Body)
-	if err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		w.Write(buf)
-	} else {
-		w.WriteHeader(http.StatusOK)
-		w.Write(buf)
-	}
-}
-
-func HttpClientSetupForTest(t *testing.T) (net.Listener, net.Addr) {
-	addr, err := FindAvailableTCPServerPort(40000)
-	if err != nil {
-		t.Fatalf("Unable to find available tcp port addr: %s", err)
-		return nil, addr
-	}
-	l, err := net.Listen(addr.Network(), addr.String())
-	if err != nil {
-		t.Fatalf("Unable to setup tcp listener on %s: %s", addr.String(), err)
-		return l, addr
-	}
-	go http.Serve(l, &HTTPEchoServer{})
-	return l, addr
-}
-
-func HttpClientSetupForHeaderTest(t *testing.T) (net.Listener, net.Addr) {
-	addr, err := FindAvailableTCPServerPort(40000)
-	if err != nil {
-		t.Fatalf("Unable to find available tcp port addr: %s", err)
-		return nil, addr
-	}
-	l, err := net.Listen(addr.Network(), addr.String())
-	if err != nil {
-		t.Fatalf("Unable to setup tcp listener on %s: %s", addr.String(), err)
-		return l, addr
-	}
-	go http.Serve(l, &HTTPHeaderEchoServer{})
-	return l, addr
-}
-
-func ReadWriteProtocolTest(t *testing.T, protocolFactory TProtocolFactory) {
-	buf := bytes.NewBuffer(make([]byte, 0, 1024))
-	l, addr := HttpClientSetupForTest(t)
-	defer l.Close()
-	transports := []TTransportFactory{
-		NewTMemoryBufferTransportFactory(1024),
-		NewStreamTransportFactory(buf, buf, true),
-		NewTFramedTransportFactory(NewTMemoryBufferTransportFactory(1024)),
-		NewTZlibTransportFactoryWithFactory(0, NewTMemoryBufferTransportFactory(1024)),
-		NewTZlibTransportFactoryWithFactory(6, NewTMemoryBufferTransportFactory(1024)),
-		NewTZlibTransportFactoryWithFactory(9, NewTFramedTransportFactory(NewTMemoryBufferTransportFactory(1024))),
-		NewTHttpPostClientTransportFactory("http://" + addr.String()),
-	}
-	for _, tf := range transports {
-		trans, err := tf.GetTransport(nil)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		p := protocolFactory.GetProtocol(trans)
-		ReadWriteBool(t, p, trans)
-		trans.Close()
-	}
-	for _, tf := range transports {
-		trans, err := tf.GetTransport(nil)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		p := protocolFactory.GetProtocol(trans)
-		ReadWriteByte(t, p, trans)
-		trans.Close()
-	}
-	for _, tf := range transports {
-		trans, err := tf.GetTransport(nil)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		p := protocolFactory.GetProtocol(trans)
-		ReadWriteI16(t, p, trans)
-		trans.Close()
-	}
-	for _, tf := range transports {
-		trans, err := tf.GetTransport(nil)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		p := protocolFactory.GetProtocol(trans)
-		ReadWriteI32(t, p, trans)
-		trans.Close()
-	}
-	for _, tf := range transports {
-		trans, err := tf.GetTransport(nil)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		p := protocolFactory.GetProtocol(trans)
-		ReadWriteI64(t, p, trans)
-		trans.Close()
-	}
-	for _, tf := range transports {
-		trans, err := tf.GetTransport(nil)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		p := protocolFactory.GetProtocol(trans)
-		ReadWriteDouble(t, p, trans)
-		trans.Close()
-	}
-	for _, tf := range transports {
-		trans, err := tf.GetTransport(nil)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		p := protocolFactory.GetProtocol(trans)
-		ReadWriteString(t, p, trans)
-		trans.Close()
-	}
-	for _, tf := range transports {
-		trans, err := tf.GetTransport(nil)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		p := protocolFactory.GetProtocol(trans)
-		ReadWriteBinary(t, p, trans)
-		trans.Close()
-	}
-	for _, tf := range transports {
-		trans, err := tf.GetTransport(nil)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		p := protocolFactory.GetProtocol(trans)
-		ReadWriteI64(t, p, trans)
-		ReadWriteDouble(t, p, trans)
-		ReadWriteBinary(t, p, trans)
-		ReadWriteByte(t, p, trans)
-		trans.Close()
-	}
-}
-
-func ReadWriteBool(t testing.TB, p TProtocol, trans TTransport) {
-	thetype := TType(BOOL)
-	thelen := len(BOOL_VALUES)
-	err := p.WriteListBegin(thetype, thelen)
-	if err != nil {
-		t.Errorf("%s: %T %T %q Error writing list begin: %q", "ReadWriteBool", p, trans, err, thetype)
-	}
-	for k, v := range BOOL_VALUES {
-		err = p.WriteBool(v)
-		if err != nil {
-			t.Errorf("%s: %T %T %v Error writing bool in list at index %v: %v", "ReadWriteBool", p, trans, err, k, v)
-		}
-	}
-	p.WriteListEnd()
-	if err != nil {
-		t.Errorf("%s: %T %T %v Error writing list end: %v", "ReadWriteBool", p, trans, err, BOOL_VALUES)
-	}
-	p.Flush(context.Background())
-	thetype2, thelen2, err := p.ReadListBegin()
-	if err != nil {
-		t.Errorf("%s: %T %T %v Error reading list: %v", "ReadWriteBool", p, trans, err, BOOL_VALUES)
-	}
-	_, ok := p.(*TSimpleJSONProtocol)
-	if !ok {
-		if thetype != thetype2 {
-			t.Errorf("%s: %T %T type %s != type %s", "ReadWriteBool", p, trans, thetype, thetype2)
-		}
-		if thelen != thelen2 {
-			t.Errorf("%s: %T %T len %v != len %v", "ReadWriteBool", p, trans, thelen, thelen2)
-		}
-	}
-	for k, v := range BOOL_VALUES {
-		value, err := p.ReadBool()
-		if err != nil {
-			t.Errorf("%s: %T %T %v Error reading bool at index %v: %v", "ReadWriteBool", p, trans, err, k, v)
-		}
-		if v != value {
-			t.Errorf("%s: index %v %v %v %v != %v", "ReadWriteBool", k, p, trans, v, value)
-		}
-	}
-	err = p.ReadListEnd()
-	if err != nil {
-		t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteBool", p, trans, err)
-	}
-}
-
-func ReadWriteByte(t testing.TB, p TProtocol, trans TTransport) {
-	thetype := TType(BYTE)
-	thelen := len(BYTE_VALUES)
-	err := p.WriteListBegin(thetype, thelen)
-	if err != nil {
-		t.Errorf("%s: %T %T %q Error writing list begin: %q", "ReadWriteByte", p, trans, err, thetype)
-	}
-	for k, v := range BYTE_VALUES {
-		err = p.WriteByte(v)
-		if err != nil {
-			t.Errorf("%s: %T %T %q Error writing byte in list at index %d: %q", "ReadWriteByte", p, trans, err, k, v)
-		}
-	}
-	err = p.WriteListEnd()
-	if err != nil {
-		t.Errorf("%s: %T %T %q Error writing list end: %q", "ReadWriteByte", p, trans, err, BYTE_VALUES)
-	}
-	err = p.Flush(context.Background())
-	if err != nil {
-		t.Errorf("%s: %T %T %q Error flushing list of bytes: %q", "ReadWriteByte", p, trans, err, BYTE_VALUES)
-	}
-	thetype2, thelen2, err := p.ReadListBegin()
-	if err != nil {
-		t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteByte", p, trans, err, BYTE_VALUES)
-	}
-	_, ok := p.(*TSimpleJSONProtocol)
-	if !ok {
-		if thetype != thetype2 {
-			t.Errorf("%s: %T %T type %s != type %s", "ReadWriteByte", p, trans, thetype, thetype2)
-		}
-		if thelen != thelen2 {
-			t.Errorf("%s: %T %T len %v != len %v", "ReadWriteByte", p, trans, thelen, thelen2)
-		}
-	}
-	for k, v := range BYTE_VALUES {
-		value, err := p.ReadByte()
-		if err != nil {
-			t.Errorf("%s: %T %T %q Error reading byte at index %d: %q", "ReadWriteByte", p, trans, err, k, v)
-		}
-		if v != value {
-			t.Errorf("%s: %T %T %d != %d", "ReadWriteByte", p, trans, v, value)
-		}
-	}
-	err = p.ReadListEnd()
-	if err != nil {
-		t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteByte", p, trans, err)
-	}
-}
-
-func ReadWriteI16(t testing.TB, p TProtocol, trans TTransport) {
-	thetype := TType(I16)
-	thelen := len(INT16_VALUES)
-	p.WriteListBegin(thetype, thelen)
-	for _, v := range INT16_VALUES {
-		p.WriteI16(v)
-	}
-	p.WriteListEnd()
-	p.Flush(context.Background())
-	thetype2, thelen2, err := p.ReadListBegin()
-	if err != nil {
-		t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteI16", p, trans, err, INT16_VALUES)
-	}
-	_, ok := p.(*TSimpleJSONProtocol)
-	if !ok {
-		if thetype != thetype2 {
-			t.Errorf("%s: %T %T type %s != type %s", "ReadWriteI16", p, trans, thetype, thetype2)
-		}
-		if thelen != thelen2 {
-			t.Errorf("%s: %T %T len %v != len %v", "ReadWriteI16", p, trans, thelen, thelen2)
-		}
-	}
-	for k, v := range INT16_VALUES {
-		value, err := p.ReadI16()
-		if err != nil {
-			t.Errorf("%s: %T %T %q Error reading int16 at index %d: %q", "ReadWriteI16", p, trans, err, k, v)
-		}
-		if v != value {
-			t.Errorf("%s: %T %T %d != %d", "ReadWriteI16", p, trans, v, value)
-		}
-	}
-	err = p.ReadListEnd()
-	if err != nil {
-		t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteI16", p, trans, err)
-	}
-}
-
-func ReadWriteI32(t testing.TB, p TProtocol, trans TTransport) {
-	thetype := TType(I32)
-	thelen := len(INT32_VALUES)
-	p.WriteListBegin(thetype, thelen)
-	for _, v := range INT32_VALUES {
-		p.WriteI32(v)
-	}
-	p.WriteListEnd()
-	p.Flush(context.Background())
-	thetype2, thelen2, err := p.ReadListBegin()
-	if err != nil {
-		t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteI32", p, trans, err, INT32_VALUES)
-	}
-	_, ok := p.(*TSimpleJSONProtocol)
-	if !ok {
-		if thetype != thetype2 {
-			t.Errorf("%s: %T %T type %s != type %s", "ReadWriteI32", p, trans, thetype, thetype2)
-		}
-		if thelen != thelen2 {
-			t.Errorf("%s: %T %T len %v != len %v", "ReadWriteI32", p, trans, thelen, thelen2)
-		}
-	}
-	for k, v := range INT32_VALUES {
-		value, err := p.ReadI32()
-		if err != nil {
-			t.Errorf("%s: %T %T %q Error reading int32 at index %d: %q", "ReadWriteI32", p, trans, err, k, v)
-		}
-		if v != value {
-			t.Errorf("%s: %T %T %d != %d", "ReadWriteI32", p, trans, v, value)
-		}
-	}
-	if err != nil {
-		t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteI32", p, trans, err)
-	}
-}
-
-func ReadWriteI64(t testing.TB, p TProtocol, trans TTransport) {
-	thetype := TType(I64)
-	thelen := len(INT64_VALUES)
-	p.WriteListBegin(thetype, thelen)
-	for _, v := range INT64_VALUES {
-		p.WriteI64(v)
-	}
-	p.WriteListEnd()
-	p.Flush(context.Background())
-	thetype2, thelen2, err := p.ReadListBegin()
-	if err != nil {
-		t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteI64", p, trans, err, INT64_VALUES)
-	}
-	_, ok := p.(*TSimpleJSONProtocol)
-	if !ok {
-		if thetype != thetype2 {
-			t.Errorf("%s: %T %T type %s != type %s", "ReadWriteI64", p, trans, thetype, thetype2)
-		}
-		if thelen != thelen2 {
-			t.Errorf("%s: %T %T len %v != len %v", "ReadWriteI64", p, trans, thelen, thelen2)
-		}
-	}
-	for k, v := range INT64_VALUES {
-		value, err := p.ReadI64()
-		if err != nil {
-			t.Errorf("%s: %T %T %q Error reading int64 at index %d: %q", "ReadWriteI64", p, trans, err, k, v)
-		}
-		if v != value {
-			t.Errorf("%s: %T %T %q != %q", "ReadWriteI64", p, trans, v, value)
-		}
-	}
-	if err != nil {
-		t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteI64", p, trans, err)
-	}
-}
-
-func ReadWriteDouble(t testing.TB, p TProtocol, trans TTransport) {
-	thetype := TType(DOUBLE)
-	thelen := len(DOUBLE_VALUES)
-	p.WriteListBegin(thetype, thelen)
-	for _, v := range DOUBLE_VALUES {
-		p.WriteDouble(v)
-	}
-	p.WriteListEnd()
-	p.Flush(context.Background())
-	thetype2, thelen2, err := p.ReadListBegin()
-	if err != nil {
-		t.Errorf("%s: %T %T %v Error reading list: %v", "ReadWriteDouble", p, trans, err, DOUBLE_VALUES)
-	}
-	if thetype != thetype2 {
-		t.Errorf("%s: %T %T type %s != type %s", "ReadWriteDouble", p, trans, thetype, thetype2)
-	}
-	if thelen != thelen2 {
-		t.Errorf("%s: %T %T len %v != len %v", "ReadWriteDouble", p, trans, thelen, thelen2)
-	}
-	for k, v := range DOUBLE_VALUES {
-		value, err := p.ReadDouble()
-		if err != nil {
-			t.Errorf("%s: %T %T %q Error reading double at index %d: %v", "ReadWriteDouble", p, trans, err, k, v)
-		}
-		if math.IsNaN(v) {
-			if !math.IsNaN(value) {
-				t.Errorf("%s: %T %T math.IsNaN(%v) != math.IsNaN(%v)", "ReadWriteDouble", p, trans, v, value)
-			}
-		} else if v != value {
-			t.Errorf("%s: %T %T %v != %v", "ReadWriteDouble", p, trans, v, value)
-		}
-	}
-	err = p.ReadListEnd()
-	if err != nil {
-		t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteDouble", p, trans, err)
-	}
-}
-
-func ReadWriteString(t testing.TB, p TProtocol, trans TTransport) {
-	thetype := TType(STRING)
-	thelen := len(STRING_VALUES)
-	p.WriteListBegin(thetype, thelen)
-	for _, v := range STRING_VALUES {
-		p.WriteString(v)
-	}
-	p.WriteListEnd()
-	p.Flush(context.Background())
-	thetype2, thelen2, err := p.ReadListBegin()
-	if err != nil {
-		t.Errorf("%s: %T %T %q Error reading list: %q", "ReadWriteString", p, trans, err, STRING_VALUES)
-	}
-	_, ok := p.(*TSimpleJSONProtocol)
-	if !ok {
-		if thetype != thetype2 {
-			t.Errorf("%s: %T %T type %s != type %s", "ReadWriteString", p, trans, thetype, thetype2)
-		}
-		if thelen != thelen2 {
-			t.Errorf("%s: %T %T len %v != len %v", "ReadWriteString", p, trans, thelen, thelen2)
-		}
-	}
-	for k, v := range STRING_VALUES {
-		value, err := p.ReadString()
-		if err != nil {
-			t.Errorf("%s: %T %T %q Error reading string at index %d: %q", "ReadWriteString", p, trans, err, k, v)
-		}
-		if v != value {
-			t.Errorf("%s: %T %T %v != %v", "ReadWriteString", p, trans, v, value)
-		}
-	}
-	if err != nil {
-		t.Errorf("%s: %T %T Unable to read list end: %q", "ReadWriteString", p, trans, err)
-	}
-}
-
-func ReadWriteBinary(t testing.TB, p TProtocol, trans TTransport) {
-	v := protocol_bdata
-	p.WriteBinary(v)
-	p.Flush(context.Background())
-	value, err := p.ReadBinary()
-	if err != nil {
-		t.Errorf("%s: %T %T Unable to read binary: %s", "ReadWriteBinary", p, trans, err.Error())
-	}
-	if len(v) != len(value) {
-		t.Errorf("%s: %T %T len(v) != len(value)... %d != %d", "ReadWriteBinary", p, trans, len(v), len(value))
-	} else {
-		for i := 0; i < len(v); i++ {
-			if v[i] != value[i] {
-				t.Errorf("%s: %T %T %s != %s", "ReadWriteBinary", p, trans, v, value)
-			}
-		}
-	}
-}

vendor/github.com/apache/thrift/lib/go/thrift/rich_transport.go

@@ -1,68 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import "io"
-
-type RichTransport struct {
-	TTransport
-}
-
-// Wraps Transport to provide TRichTransport interface
-func NewTRichTransport(trans TTransport) *RichTransport {
-	return &RichTransport{trans}
-}
-
-func (r *RichTransport) ReadByte() (c byte, err error) {
-	return readByte(r.TTransport)
-}
-
-func (r *RichTransport) WriteByte(c byte) error {
-	return writeByte(r.TTransport, c)
-}
-
-func (r *RichTransport) WriteString(s string) (n int, err error) {
-	return r.Write([]byte(s))
-}
-
-func (r *RichTransport) RemainingBytes() (num_bytes uint64) {
-	return r.TTransport.RemainingBytes()
-}
-
-func readByte(r io.Reader) (c byte, err error) {
-	v := [1]byte{0}
-	n, err := r.Read(v[0:1])
-	if n > 0 && (err == nil || err == io.EOF) {
-		return v[0], nil
-	}
-	if n > 0 && err != nil {
-		return v[0], err
-	}
-	if err != nil {
-		return 0, err
-	}
-	return v[0], nil
-}
-
-func writeByte(w io.Writer, c byte) error {
-	v := [1]byte{c}
-	_, err := w.Write(v[0:1])
-	return err
-}

vendor/github.com/apache/thrift/lib/go/thrift/rich_transport_test.go

@@ -1,89 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"reflect"
-	"testing"
-)
-
-func TestEnsureTransportsAreRich(t *testing.T) {
-	buf := bytes.NewBuffer(make([]byte, 0, 1024))
-
-	transports := []TTransportFactory{
-		NewTMemoryBufferTransportFactory(1024),
-		NewStreamTransportFactory(buf, buf, true),
-		NewTFramedTransportFactory(NewTMemoryBufferTransportFactory(1024)),
-		NewTHttpPostClientTransportFactory("http://127.0.0.1"),
-	}
-	for _, tf := range transports {
-		trans, err := tf.GetTransport(nil)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		_, ok := trans.(TRichTransport)
-		if !ok {
-			t.Errorf("Transport %s does not implement TRichTransport interface", reflect.ValueOf(trans))
-		}
-	}
-}
-
-// TestReadByte tests whether readByte handles error cases correctly.
-func TestReadByte(t *testing.T) {
-	for i, test := range readByteTests {
-		v, err := readByte(test.r)
-		if v != test.v {
-			t.Fatalf("TestReadByte %d: value differs. Expected %d, got %d", i, test.v, test.r.v)
-		}
-		if err != test.err {
-			t.Fatalf("TestReadByte %d: error differs. Expected %s, got %s", i, test.err, test.r.err)
-		}
-	}
-}
-
-var someError = errors.New("Some error")
-var readByteTests = []struct {
-	r   *mockReader
-	v   byte
-	err error
-}{
-	{&mockReader{0, 55, io.EOF}, 0, io.EOF},        // reader sends EOF w/o data
-	{&mockReader{0, 55, someError}, 0, someError},  // reader sends some other error
-	{&mockReader{1, 55, nil}, 55, nil},             // reader sends data w/o error
-	{&mockReader{1, 55, io.EOF}, 55, nil},          // reader sends data with EOF
-	{&mockReader{1, 55, someError}, 55, someError}, // reader sends data withsome error
-}
-
-type mockReader struct {
-	n   int
-	v   byte
-	err error
-}
-
-func (r *mockReader) Read(p []byte) (n int, err error) {
-	if r.n > 0 {
-		p[0] = r.v
-	}
-	return r.n, r.err
-}

vendor/github.com/apache/thrift/lib/go/thrift/serializer.go

@@ -1,79 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"context"
-)
-
-type TSerializer struct {
-	Transport *TMemoryBuffer
-	Protocol  TProtocol
-}
-
-type TStruct interface {
-	Write(p TProtocol) error
-	Read(p TProtocol) error
-}
-
-func NewTSerializer() *TSerializer {
-	transport := NewTMemoryBufferLen(1024)
-	protocol := NewTBinaryProtocolFactoryDefault().GetProtocol(transport)
-
-	return &TSerializer{
-		transport,
-		protocol}
-}
-
-func (t *TSerializer) WriteString(ctx context.Context, msg TStruct) (s string, err error) {
-	t.Transport.Reset()
-
-	if err = msg.Write(t.Protocol); err != nil {
-		return
-	}
-
-	if err = t.Protocol.Flush(ctx); err != nil {
-		return
-	}
-	if err = t.Transport.Flush(ctx); err != nil {
-		return
-	}
-
-	return t.Transport.String(), nil
-}
-
-func (t *TSerializer) Write(ctx context.Context, msg TStruct) (b []byte, err error) {
-	t.Transport.Reset()
-
-	if err = msg.Write(t.Protocol); err != nil {
-		return
-	}
-
-	if err = t.Protocol.Flush(ctx); err != nil {
-		return
-	}
-
-	if err = t.Transport.Flush(ctx); err != nil {
-		return
-	}
-
-	b = append(b, t.Transport.Bytes()...)
-	return
-}

vendor/github.com/apache/thrift/lib/go/thrift/serializer_test.go

@@ -1,170 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"testing"
-)
-
-type ProtocolFactory interface {
-	GetProtocol(t TTransport) TProtocol
-}
-
-func compareStructs(m, m1 MyTestStruct) (bool, error) {
-	switch {
-	case m.On != m1.On:
-		return false, errors.New("Boolean not equal")
-	case m.B != m1.B:
-		return false, errors.New("Byte not equal")
-	case m.Int16 != m1.Int16:
-		return false, errors.New("Int16 not equal")
-	case m.Int32 != m1.Int32:
-		return false, errors.New("Int32 not equal")
-	case m.Int64 != m1.Int64:
-		return false, errors.New("Int64 not equal")
-	case m.D != m1.D:
-		return false, errors.New("Double not equal")
-	case m.St != m1.St:
-		return false, errors.New("String not equal")
-
-	case len(m.Bin) != len(m1.Bin):
-		return false, errors.New("Binary size not equal")
-	case len(m.Bin) == len(m1.Bin):
-		for i := range m.Bin {
-			if m.Bin[i] != m1.Bin[i] {
-				return false, errors.New("Binary not equal")
-			}
-		}
-	case len(m.StringMap) != len(m1.StringMap):
-		return false, errors.New("StringMap size not equal")
-	case len(m.StringList) != len(m1.StringList):
-		return false, errors.New("StringList size not equal")
-	case len(m.StringSet) != len(m1.StringSet):
-		return false, errors.New("StringSet size not equal")
-
-	case m.E != m1.E:
-		return false, errors.New("MyTestEnum not equal")
-
-	default:
-		return true, nil
-
-	}
-	return true, nil
-}
-
-func ProtocolTest1(test *testing.T, pf ProtocolFactory) (bool, error) {
-	t := NewTSerializer()
-	t.Protocol = pf.GetProtocol(t.Transport)
-	var m = MyTestStruct{}
-	m.On = true
-	m.B = int8(0)
-	m.Int16 = 1
-	m.Int32 = 2
-	m.Int64 = 3
-	m.D = 4.1
-	m.St = "Test"
-	m.Bin = make([]byte, 10)
-	m.StringMap = make(map[string]string, 5)
-	m.StringList = make([]string, 5)
-	m.StringSet = make(map[string]struct{}, 5)
-	m.E = 2
-
-	s, err := t.WriteString(context.Background(), &m)
-	if err != nil {
-		return false, errors.New(fmt.Sprintf("Unable to Serialize struct\n\t %s", err))
-	}
-
-	t1 := NewTDeserializer()
-	t1.Protocol = pf.GetProtocol(t1.Transport)
-	var m1 = MyTestStruct{}
-	if err = t1.ReadString(&m1, s); err != nil {
-		return false, errors.New(fmt.Sprintf("Unable to Deserialize struct\n\t %s", err))
-
-	}
-
-	return compareStructs(m, m1)
-
-}
-
-func ProtocolTest2(test *testing.T, pf ProtocolFactory) (bool, error) {
-	t := NewTSerializer()
-	t.Protocol = pf.GetProtocol(t.Transport)
-	var m = MyTestStruct{}
-	m.On = false
-	m.B = int8(0)
-	m.Int16 = 1
-	m.Int32 = 2
-	m.Int64 = 3
-	m.D = 4.1
-	m.St = "Test"
-	m.Bin = make([]byte, 10)
-	m.StringMap = make(map[string]string, 5)
-	m.StringList = make([]string, 5)
-	m.StringSet = make(map[string]struct{}, 5)
-	m.E = 2
-
-	s, err := t.WriteString(context.Background(), &m)
-	if err != nil {
-		return false, errors.New(fmt.Sprintf("Unable to Serialize struct\n\t %s", err))
-
-	}
-
-	t1 := NewTDeserializer()
-	t1.Protocol = pf.GetProtocol(t1.Transport)
-	var m1 = MyTestStruct{}
-	if err = t1.ReadString(&m1, s); err != nil {
-		return false, errors.New(fmt.Sprintf("Unable to Deserialize struct\n\t %s", err))
-
-	}
-
-	return compareStructs(m, m1)
-
-}
-
-func TestSerializer(t *testing.T) {
-
-	var protocol_factories map[string]ProtocolFactory
-	protocol_factories = make(map[string]ProtocolFactory)
-	protocol_factories["Binary"] = NewTBinaryProtocolFactoryDefault()
-	protocol_factories["Compact"] = NewTCompactProtocolFactory()
-	//protocol_factories["SimpleJSON"] = NewTSimpleJSONProtocolFactory() - write only, can't be read back by design
-	protocol_factories["JSON"] = NewTJSONProtocolFactory()
-
-	var tests map[string]func(*testing.T, ProtocolFactory) (bool, error)
-	tests = make(map[string]func(*testing.T, ProtocolFactory) (bool, error))
-	tests["Test 1"] = ProtocolTest1
-	tests["Test 2"] = ProtocolTest2
-	//tests["Test 3"] = ProtocolTest3 // Example of how to add additional tests
-
-	for name, pf := range protocol_factories {
-
-		for test, f := range tests {
-
-			if s, err := f(t, pf); !s || err != nil {
-				t.Errorf("%s Failed for %s protocol\n\t %s", test, name, err)
-			}
-
-		}
-	}
-
-}

vendor/github.com/apache/thrift/lib/go/thrift/serializer_types_test.go

@@ -1,633 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-// Autogenerated by Thrift Compiler (0.12.0)
-// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
-
-/* THE FOLLOWING THRIFT FILE WAS USED TO CREATE THIS
-
-enum MyTestEnum {
-	FIRST = 1,
-	SECOND = 2,
-	THIRD = 3,
-	FOURTH = 4,
-}
-
-struct MyTestStruct {
-	1: bool on,
-	2: byte b,
-	3: i16 int16,
-	4: i32 int32,
-	5: i64 int64,
-	6: double d,
-	7: string st,
-	8: binary bin,
-	9: map<string, string> stringMap,
-	10: list<string> stringList,
-	11: set<string> stringSet,
-	12: MyTestEnum e,
-}
-*/
-
-import (
-	"fmt"
-)
-
-// (needed to ensure safety because of naive import list construction.)
-var _ = ZERO
-var _ = fmt.Printf
-
-var GoUnusedProtection__ int
-
-type MyTestEnum int64
-
-const (
-	MyTestEnum_FIRST  MyTestEnum = 1
-	MyTestEnum_SECOND MyTestEnum = 2
-	MyTestEnum_THIRD  MyTestEnum = 3
-	MyTestEnum_FOURTH MyTestEnum = 4
-)
-
-func (p MyTestEnum) String() string {
-	switch p {
-	case MyTestEnum_FIRST:
-		return "FIRST"
-	case MyTestEnum_SECOND:
-		return "SECOND"
-	case MyTestEnum_THIRD:
-		return "THIRD"
-	case MyTestEnum_FOURTH:
-		return "FOURTH"
-	}
-	return "<UNSET>"
-}
-
-func MyTestEnumFromString(s string) (MyTestEnum, error) {
-	switch s {
-	case "FIRST":
-		return MyTestEnum_FIRST, nil
-	case "SECOND":
-		return MyTestEnum_SECOND, nil
-	case "THIRD":
-		return MyTestEnum_THIRD, nil
-	case "FOURTH":
-		return MyTestEnum_FOURTH, nil
-	}
-	return MyTestEnum(0), fmt.Errorf("not a valid MyTestEnum string")
-}
-
-func MyTestEnumPtr(v MyTestEnum) *MyTestEnum { return &v }
-
-type MyTestStruct struct {
-	On         bool                `thrift:"on,1" json:"on"`
-	B          int8                `thrift:"b,2" json:"b"`
-	Int16      int16               `thrift:"int16,3" json:"int16"`
-	Int32      int32               `thrift:"int32,4" json:"int32"`
-	Int64      int64               `thrift:"int64,5" json:"int64"`
-	D          float64             `thrift:"d,6" json:"d"`
-	St         string              `thrift:"st,7" json:"st"`
-	Bin        []byte              `thrift:"bin,8" json:"bin"`
-	StringMap  map[string]string   `thrift:"stringMap,9" json:"stringMap"`
-	StringList []string            `thrift:"stringList,10" json:"stringList"`
-	StringSet  map[string]struct{} `thrift:"stringSet,11" json:"stringSet"`
-	E          MyTestEnum          `thrift:"e,12" json:"e"`
-}
-
-func NewMyTestStruct() *MyTestStruct {
-	return &MyTestStruct{}
-}
-
-func (p *MyTestStruct) GetOn() bool {
-	return p.On
-}
-
-func (p *MyTestStruct) GetB() int8 {
-	return p.B
-}
-
-func (p *MyTestStruct) GetInt16() int16 {
-	return p.Int16
-}
-
-func (p *MyTestStruct) GetInt32() int32 {
-	return p.Int32
-}
-
-func (p *MyTestStruct) GetInt64() int64 {
-	return p.Int64
-}
-
-func (p *MyTestStruct) GetD() float64 {
-	return p.D
-}
-
-func (p *MyTestStruct) GetSt() string {
-	return p.St
-}
-
-func (p *MyTestStruct) GetBin() []byte {
-	return p.Bin
-}
-
-func (p *MyTestStruct) GetStringMap() map[string]string {
-	return p.StringMap
-}
-
-func (p *MyTestStruct) GetStringList() []string {
-	return p.StringList
-}
-
-func (p *MyTestStruct) GetStringSet() map[string]struct{} {
-	return p.StringSet
-}
-
-func (p *MyTestStruct) GetE() MyTestEnum {
-	return p.E
-}
-func (p *MyTestStruct) Read(iprot TProtocol) error {
-	if _, err := iprot.ReadStructBegin(); err != nil {
-		return PrependError(fmt.Sprintf("%T read error: ", p), err)
-	}
-	for {
-		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
-		if err != nil {
-			return PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
-		}
-		if fieldTypeId == STOP {
-			break
-		}
-		switch fieldId {
-		case 1:
-			if err := p.readField1(iprot); err != nil {
-				return err
-			}
-		case 2:
-			if err := p.readField2(iprot); err != nil {
-				return err
-			}
-		case 3:
-			if err := p.readField3(iprot); err != nil {
-				return err
-			}
-		case 4:
-			if err := p.readField4(iprot); err != nil {
-				return err
-			}
-		case 5:
-			if err := p.readField5(iprot); err != nil {
-				return err
-			}
-		case 6:
-			if err := p.readField6(iprot); err != nil {
-				return err
-			}
-		case 7:
-			if err := p.readField7(iprot); err != nil {
-				return err
-			}
-		case 8:
-			if err := p.readField8(iprot); err != nil {
-				return err
-			}
-		case 9:
-			if err := p.readField9(iprot); err != nil {
-				return err
-			}
-		case 10:
-			if err := p.readField10(iprot); err != nil {
-				return err
-			}
-		case 11:
-			if err := p.readField11(iprot); err != nil {
-				return err
-			}
-		case 12:
-			if err := p.readField12(iprot); err != nil {
-				return err
-			}
-		default:
-			if err := iprot.Skip(fieldTypeId); err != nil {
-				return err
-			}
-		}
-		if err := iprot.ReadFieldEnd(); err != nil {
-			return err
-		}
-	}
-	if err := iprot.ReadStructEnd(); err != nil {
-		return PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
-	}
-	return nil
-}
-
-func (p *MyTestStruct) readField1(iprot TProtocol) error {
-	if v, err := iprot.ReadBool(); err != nil {
-		return PrependError("error reading field 1: ", err)
-	} else {
-		p.On = v
-	}
-	return nil
-}
-
-func (p *MyTestStruct) readField2(iprot TProtocol) error {
-	if v, err := iprot.ReadByte(); err != nil {
-		return PrependError("error reading field 2: ", err)
-	} else {
-		temp := int8(v)
-		p.B = temp
-	}
-	return nil
-}
-
-func (p *MyTestStruct) readField3(iprot TProtocol) error {
-	if v, err := iprot.ReadI16(); err != nil {
-		return PrependError("error reading field 3: ", err)
-	} else {
-		p.Int16 = v
-	}
-	return nil
-}
-
-func (p *MyTestStruct) readField4(iprot TProtocol) error {
-	if v, err := iprot.ReadI32(); err != nil {
-		return PrependError("error reading field 4: ", err)
-	} else {
-		p.Int32 = v
-	}
-	return nil
-}
-
-func (p *MyTestStruct) readField5(iprot TProtocol) error {
-	if v, err := iprot.ReadI64(); err != nil {
-		return PrependError("error reading field 5: ", err)
-	} else {
-		p.Int64 = v
-	}
-	return nil
-}
-
-func (p *MyTestStruct) readField6(iprot TProtocol) error {
-	if v, err := iprot.ReadDouble(); err != nil {
-		return PrependError("error reading field 6: ", err)
-	} else {
-		p.D = v
-	}
-	return nil
-}
-
-func (p *MyTestStruct) readField7(iprot TProtocol) error {
-	if v, err := iprot.ReadString(); err != nil {
-		return PrependError("error reading field 7: ", err)
-	} else {
-		p.St = v
-	}
-	return nil
-}
-
-func (p *MyTestStruct) readField8(iprot TProtocol) error {
-	if v, err := iprot.ReadBinary(); err != nil {
-		return PrependError("error reading field 8: ", err)
-	} else {
-		p.Bin = v
-	}
-	return nil
-}
-
-func (p *MyTestStruct) readField9(iprot TProtocol) error {
-	_, _, size, err := iprot.ReadMapBegin()
-	if err != nil {
-		return PrependError("error reading map begin: ", err)
-	}
-	tMap := make(map[string]string, size)
-	p.StringMap = tMap
-	for i := 0; i < size; i++ {
-		var _key0 string
-		if v, err := iprot.ReadString(); err != nil {
-			return PrependError("error reading field 0: ", err)
-		} else {
-			_key0 = v
-		}
-		var _val1 string
-		if v, err := iprot.ReadString(); err != nil {
-			return PrependError("error reading field 0: ", err)
-		} else {
-			_val1 = v
-		}
-		p.StringMap[_key0] = _val1
-	}
-	if err := iprot.ReadMapEnd(); err != nil {
-		return PrependError("error reading map end: ", err)
-	}
-	return nil
-}
-
-func (p *MyTestStruct) readField10(iprot TProtocol) error {
-	_, size, err := iprot.ReadListBegin()
-	if err != nil {
-		return PrependError("error reading list begin: ", err)
-	}
-	tSlice := make([]string, 0, size)
-	p.StringList = tSlice
-	for i := 0; i < size; i++ {
-		var _elem2 string
-		if v, err := iprot.ReadString(); err != nil {
-			return PrependError("error reading field 0: ", err)
-		} else {
-			_elem2 = v
-		}
-		p.StringList = append(p.StringList, _elem2)
-	}
-	if err := iprot.ReadListEnd(); err != nil {
-		return PrependError("error reading list end: ", err)
-	}
-	return nil
-}
-
-func (p *MyTestStruct) readField11(iprot TProtocol) error {
-	_, size, err := iprot.ReadSetBegin()
-	if err != nil {
-		return PrependError("error reading set begin: ", err)
-	}
-	tSet := make(map[string]struct{}, size)
-	p.StringSet = tSet
-	for i := 0; i < size; i++ {
-		var _elem3 string
-		if v, err := iprot.ReadString(); err != nil {
-			return PrependError("error reading field 0: ", err)
-		} else {
-			_elem3 = v
-		}
-		p.StringSet[_elem3] = struct{}{}
-	}
-	if err := iprot.ReadSetEnd(); err != nil {
-		return PrependError("error reading set end: ", err)
-	}
-	return nil
-}
-
-func (p *MyTestStruct) readField12(iprot TProtocol) error {
-	if v, err := iprot.ReadI32(); err != nil {
-		return PrependError("error reading field 12: ", err)
-	} else {
-		temp := MyTestEnum(v)
-		p.E = temp
-	}
-	return nil
-}
-
-func (p *MyTestStruct) Write(oprot TProtocol) error {
-	if err := oprot.WriteStructBegin("MyTestStruct"); err != nil {
-		return PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
-	}
-	if err := p.writeField1(oprot); err != nil {
-		return err
-	}
-	if err := p.writeField2(oprot); err != nil {
-		return err
-	}
-	if err := p.writeField3(oprot); err != nil {
-		return err
-	}
-	if err := p.writeField4(oprot); err != nil {
-		return err
-	}
-	if err := p.writeField5(oprot); err != nil {
-		return err
-	}
-	if err := p.writeField6(oprot); err != nil {
-		return err
-	}
-	if err := p.writeField7(oprot); err != nil {
-		return err
-	}
-	if err := p.writeField8(oprot); err != nil {
-		return err
-	}
-	if err := p.writeField9(oprot); err != nil {
-		return err
-	}
-	if err := p.writeField10(oprot); err != nil {
-		return err
-	}
-	if err := p.writeField11(oprot); err != nil {
-		return err
-	}
-	if err := p.writeField12(oprot); err != nil {
-		return err
-	}
-	if err := oprot.WriteFieldStop(); err != nil {
-		return PrependError("write field stop error: ", err)
-	}
-	if err := oprot.WriteStructEnd(); err != nil {
-		return PrependError("write struct stop error: ", err)
-	}
-	return nil
-}
-
-func (p *MyTestStruct) writeField1(oprot TProtocol) (err error) {
-	if err := oprot.WriteFieldBegin("on", BOOL, 1); err != nil {
-		return PrependError(fmt.Sprintf("%T write field begin error 1:on: ", p), err)
-	}
-	if err := oprot.WriteBool(bool(p.On)); err != nil {
-		return PrependError(fmt.Sprintf("%T.on (1) field write error: ", p), err)
-	}
-	if err := oprot.WriteFieldEnd(); err != nil {
-		return PrependError(fmt.Sprintf("%T write field end error 1:on: ", p), err)
-	}
-	return err
-}
-
-func (p *MyTestStruct) writeField2(oprot TProtocol) (err error) {
-	if err := oprot.WriteFieldBegin("b", BYTE, 2); err != nil {
-		return PrependError(fmt.Sprintf("%T write field begin error 2:b: ", p), err)
-	}
-	if err := oprot.WriteByte(int8(p.B)); err != nil {
-		return PrependError(fmt.Sprintf("%T.b (2) field write error: ", p), err)
-	}
-	if err := oprot.WriteFieldEnd(); err != nil {
-		return PrependError(fmt.Sprintf("%T write field end error 2:b: ", p), err)
-	}
-	return err
-}
-
-func (p *MyTestStruct) writeField3(oprot TProtocol) (err error) {
-	if err := oprot.WriteFieldBegin("int16", I16, 3); err != nil {
-		return PrependError(fmt.Sprintf("%T write field begin error 3:int16: ", p), err)
-	}
-	if err := oprot.WriteI16(int16(p.Int16)); err != nil {
-		return PrependError(fmt.Sprintf("%T.int16 (3) field write error: ", p), err)
-	}
-	if err := oprot.WriteFieldEnd(); err != nil {
-		return PrependError(fmt.Sprintf("%T write field end error 3:int16: ", p), err)
-	}
-	return err
-}
-
-func (p *MyTestStruct) writeField4(oprot TProtocol) (err error) {
-	if err := oprot.WriteFieldBegin("int32", I32, 4); err != nil {
-		return PrependError(fmt.Sprintf("%T write field begin error 4:int32: ", p), err)
-	}
-	if err := oprot.WriteI32(int32(p.Int32)); err != nil {
-		return PrependError(fmt.Sprintf("%T.int32 (4) field write error: ", p), err)
-	}
-	if err := oprot.WriteFieldEnd(); err != nil {
-		return PrependError(fmt.Sprintf("%T write field end error 4:int32: ", p), err)
-	}
-	return err
-}
-
-func (p *MyTestStruct) writeField5(oprot TProtocol) (err error) {
-	if err := oprot.WriteFieldBegin("int64", I64, 5); err != nil {
-		return PrependError(fmt.Sprintf("%T write field begin error 5:int64: ", p), err)
-	}
-	if err := oprot.WriteI64(int64(p.Int64)); err != nil {
-		return PrependError(fmt.Sprintf("%T.int64 (5) field write error: ", p), err)
-	}
-	if err := oprot.WriteFieldEnd(); err != nil {
-		return PrependError(fmt.Sprintf("%T write field end error 5:int64: ", p), err)
-	}
-	return err
-}
-
-func (p *MyTestStruct) writeField6(oprot TProtocol) (err error) {
-	if err := oprot.WriteFieldBegin("d", DOUBLE, 6); err != nil {
-		return PrependError(fmt.Sprintf("%T write field begin error 6:d: ", p), err)
-	}
-	if err := oprot.WriteDouble(float64(p.D)); err != nil {
-		return PrependError(fmt.Sprintf("%T.d (6) field write error: ", p), err)
-	}
-	if err := oprot.WriteFieldEnd(); err != nil {
-		return PrependError(fmt.Sprintf("%T write field end error 6:d: ", p), err)
-	}
-	return err
-}
-
-func (p *MyTestStruct) writeField7(oprot TProtocol) (err error) {
-	if err := oprot.WriteFieldBegin("st", STRING, 7); err != nil {
-		return PrependError(fmt.Sprintf("%T write field begin error 7:st: ", p), err)
-	}
-	if err := oprot.WriteString(string(p.St)); err != nil {
-		return PrependError(fmt.Sprintf("%T.st (7) field write error: ", p), err)
-	}
-	if err := oprot.WriteFieldEnd(); err != nil {
-		return PrependError(fmt.Sprintf("%T write field end error 7:st: ", p), err)
-	}
-	return err
-}
-
-func (p *MyTestStruct) writeField8(oprot TProtocol) (err error) {
-	if err := oprot.WriteFieldBegin("bin", STRING, 8); err != nil {
-		return PrependError(fmt.Sprintf("%T write field begin error 8:bin: ", p), err)
-	}
-	if err := oprot.WriteBinary(p.Bin); err != nil {
-		return PrependError(fmt.Sprintf("%T.bin (8) field write error: ", p), err)
-	}
-	if err := oprot.WriteFieldEnd(); err != nil {
-		return PrependError(fmt.Sprintf("%T write field end error 8:bin: ", p), err)
-	}
-	return err
-}
-
-func (p *MyTestStruct) writeField9(oprot TProtocol) (err error) {
-	if err := oprot.WriteFieldBegin("stringMap", MAP, 9); err != nil {
-		return PrependError(fmt.Sprintf("%T write field begin error 9:stringMap: ", p), err)
-	}
-	if err := oprot.WriteMapBegin(STRING, STRING, len(p.StringMap)); err != nil {
-		return PrependError("error writing map begin: ", err)
-	}
-	for k, v := range p.StringMap {
-		if err := oprot.WriteString(string(k)); err != nil {
-			return PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
-		}
-		if err := oprot.WriteString(string(v)); err != nil {
-			return PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
-		}
-	}
-	if err := oprot.WriteMapEnd(); err != nil {
-		return PrependError("error writing map end: ", err)
-	}
-	if err := oprot.WriteFieldEnd(); err != nil {
-		return PrependError(fmt.Sprintf("%T write field end error 9:stringMap: ", p), err)
-	}
-	return err
-}
-
-func (p *MyTestStruct) writeField10(oprot TProtocol) (err error) {
-	if err := oprot.WriteFieldBegin("stringList", LIST, 10); err != nil {
-		return PrependError(fmt.Sprintf("%T write field begin error 10:stringList: ", p), err)
-	}
-	if err := oprot.WriteListBegin(STRING, len(p.StringList)); err != nil {
-		return PrependError("error writing list begin: ", err)
-	}
-	for _, v := range p.StringList {
-		if err := oprot.WriteString(string(v)); err != nil {
-			return PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
-		}
-	}
-	if err := oprot.WriteListEnd(); err != nil {
-		return PrependError("error writing list end: ", err)
-	}
-	if err := oprot.WriteFieldEnd(); err != nil {
-		return PrependError(fmt.Sprintf("%T write field end error 10:stringList: ", p), err)
-	}
-	return err
-}
-
-func (p *MyTestStruct) writeField11(oprot TProtocol) (err error) {
-	if err := oprot.WriteFieldBegin("stringSet", SET, 11); err != nil {
-		return PrependError(fmt.Sprintf("%T write field begin error 11:stringSet: ", p), err)
-	}
-	if err := oprot.WriteSetBegin(STRING, len(p.StringSet)); err != nil {
-		return PrependError("error writing set begin: ", err)
-	}
-	for v := range p.StringSet {
-		if err := oprot.WriteString(string(v)); err != nil {
-			return PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
-		}
-	}
-	if err := oprot.WriteSetEnd(); err != nil {
-		return PrependError("error writing set end: ", err)
-	}
-	if err := oprot.WriteFieldEnd(); err != nil {
-		return PrependError(fmt.Sprintf("%T write field end error 11:stringSet: ", p), err)
-	}
-	return err
-}
-
-func (p *MyTestStruct) writeField12(oprot TProtocol) (err error) {
-	if err := oprot.WriteFieldBegin("e", I32, 12); err != nil {
-		return PrependError(fmt.Sprintf("%T write field begin error 12:e: ", p), err)
-	}
-	if err := oprot.WriteI32(int32(p.E)); err != nil {
-		return PrependError(fmt.Sprintf("%T.e (12) field write error: ", p), err)
-	}
-	if err := oprot.WriteFieldEnd(); err != nil {
-		return PrependError(fmt.Sprintf("%T write field end error 12:e: ", p), err)
-	}
-	return err
-}
-
-func (p *MyTestStruct) String() string {
-	if p == nil {
-		return "<nil>"
-	}
-	return fmt.Sprintf("MyTestStruct(%+v)", *p)
-}

vendor/github.com/apache/thrift/lib/go/thrift/server.go

@@ -1,35 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-type TServer interface {
-	ProcessorFactory() TProcessorFactory
-	ServerTransport() TServerTransport
-	InputTransportFactory() TTransportFactory
-	OutputTransportFactory() TTransportFactory
-	InputProtocolFactory() TProtocolFactory
-	OutputProtocolFactory() TProtocolFactory
-
-	// Starts the server
-	Serve() error
-	// Stops the server. This is optional on a per-implementation basis. Not
-	// all servers are required to be cleanly stoppable.
-	Stop() error
-}

vendor/github.com/apache/thrift/lib/go/thrift/server_socket.go

@@ -1,137 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"net"
-	"sync"
-	"time"
-)
-
-type TServerSocket struct {
-	listener      net.Listener
-	addr          net.Addr
-	clientTimeout time.Duration
-
-	// Protects the interrupted value to make it thread safe.
-	mu          sync.RWMutex
-	interrupted bool
-}
-
-func NewTServerSocket(listenAddr string) (*TServerSocket, error) {
-	return NewTServerSocketTimeout(listenAddr, 0)
-}
-
-func NewTServerSocketTimeout(listenAddr string, clientTimeout time.Duration) (*TServerSocket, error) {
-	addr, err := net.ResolveTCPAddr("tcp", listenAddr)
-	if err != nil {
-		return nil, err
-	}
-	return &TServerSocket{addr: addr, clientTimeout: clientTimeout}, nil
-}
-
-// Creates a TServerSocket from a net.Addr
-func NewTServerSocketFromAddrTimeout(addr net.Addr, clientTimeout time.Duration) *TServerSocket {
-	return &TServerSocket{addr: addr, clientTimeout: clientTimeout}
-}
-
-func (p *TServerSocket) Listen() error {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	if p.IsListening() {
-		return nil
-	}
-	l, err := net.Listen(p.addr.Network(), p.addr.String())
-	if err != nil {
-		return err
-	}
-	p.listener = l
-	return nil
-}
-
-func (p *TServerSocket) Accept() (TTransport, error) {
-	p.mu.RLock()
-	interrupted := p.interrupted
-	p.mu.RUnlock()
-
-	if interrupted {
-		return nil, errTransportInterrupted
-	}
-
-	p.mu.Lock()
-	listener := p.listener
-	p.mu.Unlock()
-	if listener == nil {
-		return nil, NewTTransportException(NOT_OPEN, "No underlying server socket")
-	}
-
-	conn, err := listener.Accept()
-	if err != nil {
-		return nil, NewTTransportExceptionFromError(err)
-	}
-	return NewTSocketFromConnTimeout(conn, p.clientTimeout), nil
-}
-
-// Checks whether the socket is listening.
-func (p *TServerSocket) IsListening() bool {
-	return p.listener != nil
-}
-
-// Connects the socket, creating a new socket object if necessary.
-func (p *TServerSocket) Open() error {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	if p.IsListening() {
-		return NewTTransportException(ALREADY_OPEN, "Server socket already open")
-	}
-	if l, err := net.Listen(p.addr.Network(), p.addr.String()); err != nil {
-		return err
-	} else {
-		p.listener = l
-	}
-	return nil
-}
-
-func (p *TServerSocket) Addr() net.Addr {
-	if p.listener != nil {
-		return p.listener.Addr()
-	}
-	return p.addr
-}
-
-func (p *TServerSocket) Close() error {
-	var err error
-	p.mu.Lock()
-	if p.IsListening() {
-		err = p.listener.Close()
-		p.listener = nil
-	}
-	p.mu.Unlock()
-	return err
-}
-
-func (p *TServerSocket) Interrupt() error {
-	p.mu.Lock()
-	p.interrupted = true
-	p.mu.Unlock()
-	p.Close()
-
-	return nil
-}

vendor/github.com/apache/thrift/lib/go/thrift/server_socket_test.go

@@ -1,60 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestSocketIsntListeningAfterInterrupt(t *testing.T) {
-	host := "127.0.0.1"
-	port := 9090
-	addr := fmt.Sprintf("%s:%d", host, port)
-
-	socket := CreateServerSocket(t, addr)
-	socket.Listen()
-	socket.Interrupt()
-
-	newSocket := CreateServerSocket(t, addr)
-	err := newSocket.Listen()
-	defer newSocket.Interrupt()
-	if err != nil {
-		t.Fatalf("Failed to rebinds: %s", err)
-	}
-}
-
-func TestSocketConcurrency(t *testing.T) {
-	host := "127.0.0.1"
-	port := 9090
-	addr := fmt.Sprintf("%s:%d", host, port)
-
-	socket := CreateServerSocket(t, addr)
-	go func() { socket.Listen() }()
-	go func() { socket.Interrupt() }()
-}
-
-func CreateServerSocket(t *testing.T, addr string) *TServerSocket {
-	socket, err := NewTServerSocket(addr)
-	if err != nil {
-		t.Fatalf("Failed to create server socket: %s", err)
-	}
-	return socket
-}

vendor/github.com/apache/thrift/lib/go/thrift/server_test.go

@@ -1,28 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"testing"
-)
-
-func TestNothing(t *testing.T) {
-
-}

vendor/github.com/apache/thrift/lib/go/thrift/server_transport.go

@@ -1,34 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-// Server transport. Object which provides client transports.
-type TServerTransport interface {
-	Listen() error
-	Accept() (TTransport, error)
-	Close() error
-
-	// Optional method implementation. This signals to the server transport
-	// that it should break out of any accept() or listen() that it is currently
-	// blocked on. This method, if implemented, MUST be thread safe, as it may
-	// be called from a different thread context than the other TServerTransport
-	// methods.
-	Interrupt() error
-}

vendor/github.com/apache/thrift/lib/go/thrift/simple_json_protocol_test.go

@@ -1,716 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"math"
-	"strconv"
-	"strings"
-	"testing"
-)
-
-func TestWriteSimpleJSONProtocolBool(t *testing.T) {
-	thetype := "boolean"
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	for _, value := range BOOL_VALUES {
-		if e := p.WriteBool(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		if s != fmt.Sprint(value) {
-			t.Fatalf("Bad value for %s %v: %s", thetype, value, s)
-		}
-		v := false
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadSimpleJSONProtocolBool(t *testing.T) {
-	thetype := "boolean"
-	for _, value := range BOOL_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTSimpleJSONProtocol(trans)
-		if value {
-			trans.Write(JSON_TRUE)
-		} else {
-			trans.Write(JSON_FALSE)
-		}
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadBool()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if v != value {
-			t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-		}
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-
-func TestWriteSimpleJSONProtocolByte(t *testing.T) {
-	thetype := "byte"
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	for _, value := range BYTE_VALUES {
-		if e := p.WriteByte(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		if s != fmt.Sprint(value) {
-			t.Fatalf("Bad value for %s %v: %s", thetype, value, s)
-		}
-		v := int8(0)
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadSimpleJSONProtocolByte(t *testing.T) {
-	thetype := "byte"
-	for _, value := range BYTE_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTSimpleJSONProtocol(trans)
-		trans.WriteString(strconv.Itoa(int(value)))
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadByte()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if v != value {
-			t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-		}
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-
-func TestWriteSimpleJSONProtocolI16(t *testing.T) {
-	thetype := "int16"
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	for _, value := range INT16_VALUES {
-		if e := p.WriteI16(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		if s != fmt.Sprint(value) {
-			t.Fatalf("Bad value for %s %v: %s", thetype, value, s)
-		}
-		v := int16(0)
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadSimpleJSONProtocolI16(t *testing.T) {
-	thetype := "int16"
-	for _, value := range INT16_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTSimpleJSONProtocol(trans)
-		trans.WriteString(strconv.Itoa(int(value)))
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadI16()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if v != value {
-			t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-		}
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-
-func TestWriteSimpleJSONProtocolI32(t *testing.T) {
-	thetype := "int32"
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	for _, value := range INT32_VALUES {
-		if e := p.WriteI32(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		if s != fmt.Sprint(value) {
-			t.Fatalf("Bad value for %s %v: %s", thetype, value, s)
-		}
-		v := int32(0)
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadSimpleJSONProtocolI32(t *testing.T) {
-	thetype := "int32"
-	for _, value := range INT32_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTSimpleJSONProtocol(trans)
-		trans.WriteString(strconv.Itoa(int(value)))
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadI32()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if v != value {
-			t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-		}
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-
-func TestReadSimpleJSONProtocolI32Null(t *testing.T) {
-	thetype := "int32"
-	value := "null"
-
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	trans.WriteString(value)
-	trans.Flush(context.Background())
-	s := trans.String()
-	v, e := p.ReadI32()
-
-	if e != nil {
-		t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-	}
-	if v != 0 {
-		t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-	}
-	trans.Reset()
-	trans.Close()
-}
-
-func TestWriteSimpleJSONProtocolI64(t *testing.T) {
-	thetype := "int64"
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	for _, value := range INT64_VALUES {
-		if e := p.WriteI64(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		if s != fmt.Sprint(value) {
-			t.Fatalf("Bad value for %s %v: %s", thetype, value, s)
-		}
-		v := int64(0)
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadSimpleJSONProtocolI64(t *testing.T) {
-	thetype := "int64"
-	for _, value := range INT64_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTSimpleJSONProtocol(trans)
-		trans.WriteString(strconv.FormatInt(value, 10))
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadI64()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if v != value {
-			t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-		}
-		if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-
-func TestReadSimpleJSONProtocolI64Null(t *testing.T) {
-	thetype := "int32"
-	value := "null"
-
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	trans.WriteString(value)
-	trans.Flush(context.Background())
-	s := trans.String()
-	v, e := p.ReadI64()
-
-	if e != nil {
-		t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-	}
-	if v != 0 {
-		t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-	}
-	trans.Reset()
-	trans.Close()
-}
-
-func TestWriteSimpleJSONProtocolDouble(t *testing.T) {
-	thetype := "double"
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	for _, value := range DOUBLE_VALUES {
-		if e := p.WriteDouble(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		if math.IsInf(value, 1) {
-			if s != jsonQuote(JSON_INFINITY) {
-				t.Fatalf("Bad value for %s %v, wrote: %v, expected: %v", thetype, value, s, jsonQuote(JSON_INFINITY))
-			}
-		} else if math.IsInf(value, -1) {
-			if s != jsonQuote(JSON_NEGATIVE_INFINITY) {
-				t.Fatalf("Bad value for %s %v, wrote: %v, expected: %v", thetype, value, s, jsonQuote(JSON_NEGATIVE_INFINITY))
-			}
-		} else if math.IsNaN(value) {
-			if s != jsonQuote(JSON_NAN) {
-				t.Fatalf("Bad value for %s %v, wrote: %v, expected: %v", thetype, value, s, jsonQuote(JSON_NAN))
-			}
-		} else {
-			if s != fmt.Sprint(value) {
-				t.Fatalf("Bad value for %s %v: %s", thetype, value, s)
-			}
-			v := float64(0)
-			if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-				t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-			}
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadSimpleJSONProtocolDouble(t *testing.T) {
-	thetype := "double"
-	for _, value := range DOUBLE_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTSimpleJSONProtocol(trans)
-		n := NewNumericFromDouble(value)
-		trans.WriteString(n.String())
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadDouble()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if math.IsInf(value, 1) {
-			if !math.IsInf(v, 1) {
-				t.Fatalf("Bad value for %s %v, wrote: %v, received: %v", thetype, value, s, v)
-			}
-		} else if math.IsInf(value, -1) {
-			if !math.IsInf(v, -1) {
-				t.Fatalf("Bad value for %s %v, wrote: %v, received: %v", thetype, value, s, v)
-			}
-		} else if math.IsNaN(value) {
-			if !math.IsNaN(v) {
-				t.Fatalf("Bad value for %s %v, wrote: %v, received: %v", thetype, value, s, v)
-			}
-		} else {
-			if v != value {
-				t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-			}
-			if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-				t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-			}
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-
-func TestWriteSimpleJSONProtocolString(t *testing.T) {
-	thetype := "string"
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	for _, value := range STRING_VALUES {
-		if e := p.WriteString(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if e := p.Flush(context.Background()); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-		}
-		s := trans.String()
-		if s[0] != '"' || s[len(s)-1] != '"' {
-			t.Fatalf("Bad value for %s '%v', wrote '%v', expected: %v", thetype, value, s, fmt.Sprint("\"", value, "\""))
-		}
-		v := new(string)
-		if err := json.Unmarshal([]byte(s), v); err != nil || *v != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, *v)
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestReadSimpleJSONProtocolString(t *testing.T) {
-	thetype := "string"
-	for _, value := range STRING_VALUES {
-		trans := NewTMemoryBuffer()
-		p := NewTSimpleJSONProtocol(trans)
-		trans.WriteString(jsonQuote(value))
-		trans.Flush(context.Background())
-		s := trans.String()
-		v, e := p.ReadString()
-		if e != nil {
-			t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-		}
-		if v != value {
-			t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-		}
-		v1 := new(string)
-		if err := json.Unmarshal([]byte(s), v1); err != nil || *v1 != value {
-			t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, *v1)
-		}
-		trans.Reset()
-		trans.Close()
-	}
-}
-func TestReadSimpleJSONProtocolStringNull(t *testing.T) {
-	thetype := "string"
-	value := "null"
-
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	trans.WriteString(value)
-	trans.Flush(context.Background())
-	s := trans.String()
-	v, e := p.ReadString()
-	if e != nil {
-		t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-	}
-	if v != "" {
-		t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-	}
-	trans.Reset()
-	trans.Close()
-}
-
-func TestWriteSimpleJSONProtocolBinary(t *testing.T) {
-	thetype := "binary"
-	value := protocol_bdata
-	b64value := make([]byte, base64.StdEncoding.EncodedLen(len(protocol_bdata)))
-	base64.StdEncoding.Encode(b64value, value)
-	b64String := string(b64value)
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	if e := p.WriteBinary(value); e != nil {
-		t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-	}
-	if e := p.Flush(context.Background()); e != nil {
-		t.Fatalf("Unable to write %s value %v due to error flushing: %s", thetype, value, e.Error())
-	}
-	s := trans.String()
-	if s != fmt.Sprint("\"", b64String, "\"") {
-		t.Fatalf("Bad value for %s %v\n  wrote: %v\nexpected: %v", thetype, value, s, "\""+b64String+"\"")
-	}
-	v1 := new(string)
-	if err := json.Unmarshal([]byte(s), v1); err != nil || *v1 != b64String {
-		t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, *v1)
-	}
-	trans.Close()
-}
-
-func TestReadSimpleJSONProtocolBinary(t *testing.T) {
-	thetype := "binary"
-	value := protocol_bdata
-	b64value := make([]byte, base64.StdEncoding.EncodedLen(len(protocol_bdata)))
-	base64.StdEncoding.Encode(b64value, value)
-	b64String := string(b64value)
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	trans.WriteString(jsonQuote(b64String))
-	trans.Flush(context.Background())
-	s := trans.String()
-	v, e := p.ReadBinary()
-	if e != nil {
-		t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-	}
-	if len(v) != len(value) {
-		t.Fatalf("Bad value for %s value length %v, wrote: %v, received length: %v", thetype, len(value), s, len(v))
-	}
-	for i := 0; i < len(v); i++ {
-		if v[i] != value[i] {
-			t.Fatalf("Bad value for %s at index %d value %v, wrote: %v, received: %v", thetype, i, value[i], s, v[i])
-		}
-	}
-	v1 := new(string)
-	if err := json.Unmarshal([]byte(s), v1); err != nil || *v1 != b64String {
-		t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, *v1)
-	}
-	trans.Reset()
-	trans.Close()
-}
-
-func TestReadSimpleJSONProtocolBinaryNull(t *testing.T) {
-	thetype := "binary"
-	value := "null"
-
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	trans.WriteString(value)
-	trans.Flush(context.Background())
-	s := trans.String()
-	b, e := p.ReadBinary()
-	v := string(b)
-
-	if e != nil {
-		t.Fatalf("Unable to read %s value %v due to error: %s", thetype, value, e.Error())
-	}
-	if v != "" {
-		t.Fatalf("Bad value for %s value %v, wrote: %v, received: %v", thetype, value, s, v)
-	}
-	trans.Reset()
-	trans.Close()
-}
-
-func TestWriteSimpleJSONProtocolList(t *testing.T) {
-	thetype := "list"
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	p.WriteListBegin(TType(DOUBLE), len(DOUBLE_VALUES))
-	for _, value := range DOUBLE_VALUES {
-		if e := p.WriteDouble(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-	}
-	p.WriteListEnd()
-	if e := p.Flush(context.Background()); e != nil {
-		t.Fatalf("Unable to write %s due to error flushing: %s", thetype, e.Error())
-	}
-	str := trans.String()
-	str1 := new([]interface{})
-	err := json.Unmarshal([]byte(str), str1)
-	if err != nil {
-		t.Fatalf("Unable to decode %s, wrote: %s", thetype, str)
-	}
-	l := *str1
-	if len(l) < 2 {
-		t.Fatalf("List must be at least of length two to include metadata")
-	}
-	if int(l[0].(float64)) != DOUBLE {
-		t.Fatal("Invalid type for list, expected: ", DOUBLE, ", but was: ", l[0])
-	}
-	if int(l[1].(float64)) != len(DOUBLE_VALUES) {
-		t.Fatal("Invalid length for list, expected: ", len(DOUBLE_VALUES), ", but was: ", l[1])
-	}
-	for k, value := range DOUBLE_VALUES {
-		s := l[k+2]
-		if math.IsInf(value, 1) {
-			if s.(string) != JSON_INFINITY {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %q, expected: %q, originally wrote: %q", thetype, k, value, s, jsonQuote(JSON_INFINITY), str)
-			}
-		} else if math.IsInf(value, 0) {
-			if s.(string) != JSON_NEGATIVE_INFINITY {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %q, expected: %q, originally wrote: %q", thetype, k, value, s, jsonQuote(JSON_NEGATIVE_INFINITY), str)
-			}
-		} else if math.IsNaN(value) {
-			if s.(string) != JSON_NAN {
-				t.Fatalf("Bad value for %s at index %v  %v, wrote: %q, expected: %q, originally wrote: %q", thetype, k, value, s, jsonQuote(JSON_NAN), str)
-			}
-		} else {
-			if s.(float64) != value {
-				t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s'", thetype, value, s)
-			}
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestWriteSimpleJSONProtocolSet(t *testing.T) {
-	thetype := "set"
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	p.WriteSetBegin(TType(DOUBLE), len(DOUBLE_VALUES))
-	for _, value := range DOUBLE_VALUES {
-		if e := p.WriteDouble(value); e != nil {
-			t.Fatalf("Unable to write %s value %v due to error: %s", thetype, value, e.Error())
-		}
-	}
-	p.WriteSetEnd()
-	if e := p.Flush(context.Background()); e != nil {
-		t.Fatalf("Unable to write %s due to error flushing: %s", thetype, e.Error())
-	}
-	str := trans.String()
-	str1 := new([]interface{})
-	err := json.Unmarshal([]byte(str), str1)
-	if err != nil {
-		t.Fatalf("Unable to decode %s, wrote: %s", thetype, str)
-	}
-	l := *str1
-	if len(l) < 2 {
-		t.Fatalf("Set must be at least of length two to include metadata")
-	}
-	if int(l[0].(float64)) != DOUBLE {
-		t.Fatal("Invalid type for set, expected: ", DOUBLE, ", but was: ", l[0])
-	}
-	if int(l[1].(float64)) != len(DOUBLE_VALUES) {
-		t.Fatal("Invalid length for set, expected: ", len(DOUBLE_VALUES), ", but was: ", l[1])
-	}
-	for k, value := range DOUBLE_VALUES {
-		s := l[k+2]
-		if math.IsInf(value, 1) {
-			if s.(string) != JSON_INFINITY {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %q, expected: %q, originally wrote: %q", thetype, k, value, s, jsonQuote(JSON_INFINITY), str)
-			}
-		} else if math.IsInf(value, 0) {
-			if s.(string) != JSON_NEGATIVE_INFINITY {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %q, expected: %q, originally wrote: %q", thetype, k, value, s, jsonQuote(JSON_NEGATIVE_INFINITY), str)
-			}
-		} else if math.IsNaN(value) {
-			if s.(string) != JSON_NAN {
-				t.Fatalf("Bad value for %s at index %v  %v, wrote: %q, expected: %q, originally wrote: %q", thetype, k, value, s, jsonQuote(JSON_NAN), str)
-			}
-		} else {
-			if s.(float64) != value {
-				t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s'", thetype, value, s)
-			}
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}
-
-func TestWriteSimpleJSONProtocolMap(t *testing.T) {
-	thetype := "map"
-	trans := NewTMemoryBuffer()
-	p := NewTSimpleJSONProtocol(trans)
-	p.WriteMapBegin(TType(I32), TType(DOUBLE), len(DOUBLE_VALUES))
-	for k, value := range DOUBLE_VALUES {
-		if e := p.WriteI32(int32(k)); e != nil {
-			t.Fatalf("Unable to write %s key int32 value %v due to error: %s", thetype, k, e.Error())
-		}
-		if e := p.WriteDouble(value); e != nil {
-			t.Fatalf("Unable to write %s value float64 value %v due to error: %s", thetype, value, e.Error())
-		}
-	}
-	p.WriteMapEnd()
-	if e := p.Flush(context.Background()); e != nil {
-		t.Fatalf("Unable to write %s due to error flushing: %s", thetype, e.Error())
-	}
-	str := trans.String()
-	if str[0] != '[' || str[len(str)-1] != ']' {
-		t.Fatalf("Bad value for %s, wrote: %v, in go: %v", thetype, str, DOUBLE_VALUES)
-	}
-	l := strings.Split(str[1:len(str)-1], ",")
-	if len(l) < 3 {
-		t.Fatal("Expected list of at least length 3 for map for metadata, but was of length ", len(l))
-	}
-	expectedKeyType, _ := strconv.Atoi(l[0])
-	expectedValueType, _ := strconv.Atoi(l[1])
-	expectedSize, _ := strconv.Atoi(l[2])
-	if expectedKeyType != I32 {
-		t.Fatal("Expected map key type ", I32, ", but was ", l[0])
-	}
-	if expectedValueType != DOUBLE {
-		t.Fatal("Expected map value type ", DOUBLE, ", but was ", l[1])
-	}
-	if expectedSize != len(DOUBLE_VALUES) {
-		t.Fatal("Expected map size of ", len(DOUBLE_VALUES), ", but was ", l[2])
-	}
-	for k, value := range DOUBLE_VALUES {
-		strk := l[k*2+3]
-		strv := l[k*2+4]
-		ik, err := strconv.Atoi(strk)
-		if err != nil {
-			t.Fatalf("Bad value for %s index %v, wrote: %v, expected: %v, error: %s", thetype, k, strk, string(k), err.Error())
-		}
-		if ik != k {
-			t.Fatalf("Bad value for %s index %v, wrote: %v, expected: %v", thetype, k, strk, k)
-		}
-		s := strv
-		if math.IsInf(value, 1) {
-			if s != jsonQuote(JSON_INFINITY) {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %v, expected: %v", thetype, k, value, s, jsonQuote(JSON_INFINITY))
-			}
-		} else if math.IsInf(value, 0) {
-			if s != jsonQuote(JSON_NEGATIVE_INFINITY) {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %v, expected: %v", thetype, k, value, s, jsonQuote(JSON_NEGATIVE_INFINITY))
-			}
-		} else if math.IsNaN(value) {
-			if s != jsonQuote(JSON_NAN) {
-				t.Fatalf("Bad value for %s at index %v  %v, wrote: %v, expected: %v", thetype, k, value, s, jsonQuote(JSON_NAN))
-			}
-		} else {
-			expected := strconv.FormatFloat(value, 'g', 10, 64)
-			if s != expected {
-				t.Fatalf("Bad value for %s at index %v %v, wrote: %v, expected %v", thetype, k, value, s, expected)
-			}
-			v := float64(0)
-			if err := json.Unmarshal([]byte(s), &v); err != nil || v != value {
-				t.Fatalf("Bad json-decoded value for %s %v, wrote: '%s', expected: '%v'", thetype, value, s, v)
-			}
-		}
-		trans.Reset()
-	}
-	trans.Close()
-}

vendor/github.com/apache/thrift/lib/go/thrift/simple_server.go

@@ -1,227 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"log"
-	"runtime/debug"
-	"sync"
-	"sync/atomic"
-)
-
-/*
- * This is not a typical TSimpleServer as it is not blocked after accept a socket.
- * It is more like a TThreadedServer that can handle different connections in different goroutines.
- * This will work if golang user implements a conn-pool like thing in client side.
- */
-type TSimpleServer struct {
-	closed int32
-	wg     sync.WaitGroup
-	mu     sync.Mutex
-
-	processorFactory       TProcessorFactory
-	serverTransport        TServerTransport
-	inputTransportFactory  TTransportFactory
-	outputTransportFactory TTransportFactory
-	inputProtocolFactory   TProtocolFactory
-	outputProtocolFactory  TProtocolFactory
-}
-
-func NewTSimpleServer2(processor TProcessor, serverTransport TServerTransport) *TSimpleServer {
-	return NewTSimpleServerFactory2(NewTProcessorFactory(processor), serverTransport)
-}
-
-func NewTSimpleServer4(processor TProcessor, serverTransport TServerTransport, transportFactory TTransportFactory, protocolFactory TProtocolFactory) *TSimpleServer {
-	return NewTSimpleServerFactory4(NewTProcessorFactory(processor),
-		serverTransport,
-		transportFactory,
-		protocolFactory,
-	)
-}
-
-func NewTSimpleServer6(processor TProcessor, serverTransport TServerTransport, inputTransportFactory TTransportFactory, outputTransportFactory TTransportFactory, inputProtocolFactory TProtocolFactory, outputProtocolFactory TProtocolFactory) *TSimpleServer {
-	return NewTSimpleServerFactory6(NewTProcessorFactory(processor),
-		serverTransport,
-		inputTransportFactory,
-		outputTransportFactory,
-		inputProtocolFactory,
-		outputProtocolFactory,
-	)
-}
-
-func NewTSimpleServerFactory2(processorFactory TProcessorFactory, serverTransport TServerTransport) *TSimpleServer {
-	return NewTSimpleServerFactory6(processorFactory,
-		serverTransport,
-		NewTTransportFactory(),
-		NewTTransportFactory(),
-		NewTBinaryProtocolFactoryDefault(),
-		NewTBinaryProtocolFactoryDefault(),
-	)
-}
-
-func NewTSimpleServerFactory4(processorFactory TProcessorFactory, serverTransport TServerTransport, transportFactory TTransportFactory, protocolFactory TProtocolFactory) *TSimpleServer {
-	return NewTSimpleServerFactory6(processorFactory,
-		serverTransport,
-		transportFactory,
-		transportFactory,
-		protocolFactory,
-		protocolFactory,
-	)
-}
-
-func NewTSimpleServerFactory6(processorFactory TProcessorFactory, serverTransport TServerTransport, inputTransportFactory TTransportFactory, outputTransportFactory TTransportFactory, inputProtocolFactory TProtocolFactory, outputProtocolFactory TProtocolFactory) *TSimpleServer {
-	return &TSimpleServer{
-		processorFactory:       processorFactory,
-		serverTransport:        serverTransport,
-		inputTransportFactory:  inputTransportFactory,
-		outputTransportFactory: outputTransportFactory,
-		inputProtocolFactory:   inputProtocolFactory,
-		outputProtocolFactory:  outputProtocolFactory,
-	}
-}
-
-func (p *TSimpleServer) ProcessorFactory() TProcessorFactory {
-	return p.processorFactory
-}
-
-func (p *TSimpleServer) ServerTransport() TServerTransport {
-	return p.serverTransport
-}
-
-func (p *TSimpleServer) InputTransportFactory() TTransportFactory {
-	return p.inputTransportFactory
-}
-
-func (p *TSimpleServer) OutputTransportFactory() TTransportFactory {
-	return p.outputTransportFactory
-}
-
-func (p *TSimpleServer) InputProtocolFactory() TProtocolFactory {
-	return p.inputProtocolFactory
-}
-
-func (p *TSimpleServer) OutputProtocolFactory() TProtocolFactory {
-	return p.outputProtocolFactory
-}
-
-func (p *TSimpleServer) Listen() error {
-	return p.serverTransport.Listen()
-}
-
-func (p *TSimpleServer) innerAccept() (int32, error) {
-	client, err := p.serverTransport.Accept()
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	closed := atomic.LoadInt32(&p.closed)
-	if closed != 0 {
-		return closed, nil
-	}
-	if err != nil {
-		return 0, err
-	}
-	if client != nil {
-		p.wg.Add(1)
-		go func() {
-			defer p.wg.Done()
-			if err := p.processRequests(client); err != nil {
-				log.Println("error processing request:", err)
-			}
-		}()
-	}
-	return 0, nil
-}
-
-func (p *TSimpleServer) AcceptLoop() error {
-	for {
-		closed, err := p.innerAccept()
-		if err != nil {
-			return err
-		}
-		if closed != 0 {
-			return nil
-		}
-	}
-}
-
-func (p *TSimpleServer) Serve() error {
-	err := p.Listen()
-	if err != nil {
-		return err
-	}
-	p.AcceptLoop()
-	return nil
-}
-
-func (p *TSimpleServer) Stop() error {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	if atomic.LoadInt32(&p.closed) != 0 {
-		return nil
-	}
-	atomic.StoreInt32(&p.closed, 1)
-	p.serverTransport.Interrupt()
-	p.wg.Wait()
-	return nil
-}
-
-func (p *TSimpleServer) processRequests(client TTransport) error {
-	processor := p.processorFactory.GetProcessor(client)
-	inputTransport, err := p.inputTransportFactory.GetTransport(client)
-	if err != nil {
-		return err
-	}
-	outputTransport, err := p.outputTransportFactory.GetTransport(client)
-	if err != nil {
-		return err
-	}
-	inputProtocol := p.inputProtocolFactory.GetProtocol(inputTransport)
-	outputProtocol := p.outputProtocolFactory.GetProtocol(outputTransport)
-	defer func() {
-		if e := recover(); e != nil {
-			log.Printf("panic in processor: %s: %s", e, debug.Stack())
-		}
-	}()
-
-	if inputTransport != nil {
-		defer inputTransport.Close()
-	}
-	if outputTransport != nil {
-		defer outputTransport.Close()
-	}
-	for {
-		if atomic.LoadInt32(&p.closed) != 0 {
-			return nil
-		}
-
-		ok, err := processor.Process(defaultCtx, inputProtocol, outputProtocol)
-		if err, ok := err.(TTransportException); ok && err.TypeId() == END_OF_FILE {
-			return nil
-		} else if err != nil {
-			return err
-		}
-		if err, ok := err.(TApplicationException); ok && err.TypeId() == UNKNOWN_METHOD {
-			continue
-		}
-		if !ok {
-			break
-		}
-	}
-	return nil
-}

vendor/github.com/apache/thrift/lib/go/thrift/simple_server_test.go

@@ -1,156 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"testing"
-	"errors"
-	"runtime"
-)
-
-type mockServerTransport struct {
-	ListenFunc    func() error
-	AcceptFunc    func() (TTransport, error)
-	CloseFunc     func() error
-	InterruptFunc func() error
-}
-
-func (m *mockServerTransport) Listen() error {
-	return m.ListenFunc()
-}
-
-func (m *mockServerTransport) Accept() (TTransport, error) {
-	return m.AcceptFunc()
-}
-
-func (m *mockServerTransport) Close() error {
-	return m.CloseFunc()
-}
-
-func (m *mockServerTransport) Interrupt() error {
-	return m.InterruptFunc()
-}
-
-type mockTTransport struct {
-	TTransport
-}
-
-func (m *mockTTransport) Close() error {
-	return nil
-}
-
-func TestMultipleStop(t *testing.T) {
-	proc := &mockProcessor{
-		ProcessFunc: func(in, out TProtocol) (bool, TException) {
-			return false, nil
-		},
-	}
-
-	var interruptCalled bool
-	c := make(chan struct{})
-	trans := &mockServerTransport{
-		ListenFunc: func() error {
-			return nil
-		},
-		AcceptFunc: func() (TTransport, error) {
-			<-c
-			return nil, nil
-		},
-		CloseFunc: func() error {
-			c <- struct{}{}
-			return nil
-		},
-		InterruptFunc: func() error {
-			interruptCalled = true
-			return nil
-		},
-	}
-
-	serv := NewTSimpleServer2(proc, trans)
-	go serv.Serve()
-	serv.Stop()
-	if !interruptCalled {
-		t.Error("first server transport should have been interrupted")
-	}
-
-	serv = NewTSimpleServer2(proc, trans)
-	interruptCalled = false
-	go serv.Serve()
-	serv.Stop()
-	if !interruptCalled {
-		t.Error("second server transport should have been interrupted")
-	}
-}
-
-func TestWaitRace(t *testing.T) {
-	proc := &mockProcessor{
-		ProcessFunc: func(in, out TProtocol) (bool, TException) {
-			return false, nil
-		},
-	}
-
-	trans := &mockServerTransport{
-		ListenFunc: func() error {
-			return nil
-		},
-		AcceptFunc: func() (TTransport, error) {
-			return &mockTTransport{}, nil
-		},
-		CloseFunc: func() error {
-			return nil
-		},
-		InterruptFunc: func() error {
-			return nil
-		},
-	}
-
-	serv := NewTSimpleServer2(proc, trans)
-	go serv.Serve()
-	runtime.Gosched()
-	serv.Stop()
-}
-
-func TestNoHangDuringStopFromDanglingLockAcquireDuringAcceptLoop(t *testing.T) {
-	proc := &mockProcessor{
-		ProcessFunc: func(in, out TProtocol) (bool, TException) {
-			return false, nil
-		},
-	}
-
-	trans := &mockServerTransport{
-		ListenFunc: func() error {
-			return nil
-		},
-		AcceptFunc: func() (TTransport, error) {
-			return nil, errors.New("no sir")
-		},
-		CloseFunc: func() error {
-			return nil
-		},
-		InterruptFunc: func() error {
-			return nil
-		},
-	}
-
-	serv := NewTSimpleServer2(proc, trans)
-	go serv.Serve()
-	runtime.Gosched()
-	serv.Stop()
-}

vendor/github.com/apache/thrift/lib/go/thrift/socket.go

@@ -1,166 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"context"
-	"net"
-	"time"
-)
-
-type TSocket struct {
-	conn    net.Conn
-	addr    net.Addr
-	timeout time.Duration
-}
-
-// NewTSocket creates a net.Conn-backed TTransport, given a host and port
-//
-// Example:
-// 	trans, err := thrift.NewTSocket("localhost:9090")
-func NewTSocket(hostPort string) (*TSocket, error) {
-	return NewTSocketTimeout(hostPort, 0)
-}
-
-// NewTSocketTimeout creates a net.Conn-backed TTransport, given a host and port
-// it also accepts a timeout as a time.Duration
-func NewTSocketTimeout(hostPort string, timeout time.Duration) (*TSocket, error) {
-	//conn, err := net.DialTimeout(network, address, timeout)
-	addr, err := net.ResolveTCPAddr("tcp", hostPort)
-	if err != nil {
-		return nil, err
-	}
-	return NewTSocketFromAddrTimeout(addr, timeout), nil
-}
-
-// Creates a TSocket from a net.Addr
-func NewTSocketFromAddrTimeout(addr net.Addr, timeout time.Duration) *TSocket {
-	return &TSocket{addr: addr, timeout: timeout}
-}
-
-// Creates a TSocket from an existing net.Conn
-func NewTSocketFromConnTimeout(conn net.Conn, timeout time.Duration) *TSocket {
-	return &TSocket{conn: conn, addr: conn.RemoteAddr(), timeout: timeout}
-}
-
-// Sets the socket timeout
-func (p *TSocket) SetTimeout(timeout time.Duration) error {
-	p.timeout = timeout
-	return nil
-}
-
-func (p *TSocket) pushDeadline(read, write bool) {
-	var t time.Time
-	if p.timeout > 0 {
-		t = time.Now().Add(time.Duration(p.timeout))
-	}
-	if read && write {
-		p.conn.SetDeadline(t)
-	} else if read {
-		p.conn.SetReadDeadline(t)
-	} else if write {
-		p.conn.SetWriteDeadline(t)
-	}
-}
-
-// Connects the socket, creating a new socket object if necessary.
-func (p *TSocket) Open() error {
-	if p.IsOpen() {
-		return NewTTransportException(ALREADY_OPEN, "Socket already connected.")
-	}
-	if p.addr == nil {
-		return NewTTransportException(NOT_OPEN, "Cannot open nil address.")
-	}
-	if len(p.addr.Network()) == 0 {
-		return NewTTransportException(NOT_OPEN, "Cannot open bad network name.")
-	}
-	if len(p.addr.String()) == 0 {
-		return NewTTransportException(NOT_OPEN, "Cannot open bad address.")
-	}
-	var err error
-	if p.conn, err = net.DialTimeout(p.addr.Network(), p.addr.String(), p.timeout); err != nil {
-		return NewTTransportException(NOT_OPEN, err.Error())
-	}
-	return nil
-}
-
-// Retrieve the underlying net.Conn
-func (p *TSocket) Conn() net.Conn {
-	return p.conn
-}
-
-// Returns true if the connection is open
-func (p *TSocket) IsOpen() bool {
-	if p.conn == nil {
-		return false
-	}
-	return true
-}
-
-// Closes the socket.
-func (p *TSocket) Close() error {
-	// Close the socket
-	if p.conn != nil {
-		err := p.conn.Close()
-		if err != nil {
-			return err
-		}
-		p.conn = nil
-	}
-	return nil
-}
-
-//Returns the remote address of the socket.
-func (p *TSocket) Addr() net.Addr {
-	return p.addr
-}
-
-func (p *TSocket) Read(buf []byte) (int, error) {
-	if !p.IsOpen() {
-		return 0, NewTTransportException(NOT_OPEN, "Connection not open")
-	}
-	p.pushDeadline(true, false)
-	n, err := p.conn.Read(buf)
-	return n, NewTTransportExceptionFromError(err)
-}
-
-func (p *TSocket) Write(buf []byte) (int, error) {
-	if !p.IsOpen() {
-		return 0, NewTTransportException(NOT_OPEN, "Connection not open")
-	}
-	p.pushDeadline(false, true)
-	return p.conn.Write(buf)
-}
-
-func (p *TSocket) Flush(ctx context.Context) error {
-	return nil
-}
-
-func (p *TSocket) Interrupt() error {
-	if !p.IsOpen() {
-		return nil
-	}
-	return p.conn.Close()
-}
-
-func (p *TSocket) RemainingBytes() (num_bytes uint64) {
-	const maxSize = ^uint64(0)
-	return maxSize // the thruth is, we just don't know unless framed is used
-}

vendor/github.com/apache/thrift/lib/go/thrift/ssl_server_socket.go

@@ -1,112 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"crypto/tls"
-	"net"
-	"time"
-)
-
-type TSSLServerSocket struct {
-	listener      net.Listener
-	addr          net.Addr
-	clientTimeout time.Duration
-	interrupted   bool
-	cfg           *tls.Config
-}
-
-func NewTSSLServerSocket(listenAddr string, cfg *tls.Config) (*TSSLServerSocket, error) {
-	return NewTSSLServerSocketTimeout(listenAddr, cfg, 0)
-}
-
-func NewTSSLServerSocketTimeout(listenAddr string, cfg *tls.Config, clientTimeout time.Duration) (*TSSLServerSocket, error) {
-	if cfg.MinVersion == 0 {
-		cfg.MinVersion = tls.VersionTLS10
-	}
-	addr, err := net.ResolveTCPAddr("tcp", listenAddr)
-	if err != nil {
-		return nil, err
-	}
-	return &TSSLServerSocket{addr: addr, clientTimeout: clientTimeout, cfg: cfg}, nil
-}
-
-func (p *TSSLServerSocket) Listen() error {
-	if p.IsListening() {
-		return nil
-	}
-	l, err := tls.Listen(p.addr.Network(), p.addr.String(), p.cfg)
-	if err != nil {
-		return err
-	}
-	p.listener = l
-	return nil
-}
-
-func (p *TSSLServerSocket) Accept() (TTransport, error) {
-	if p.interrupted {
-		return nil, errTransportInterrupted
-	}
-	if p.listener == nil {
-		return nil, NewTTransportException(NOT_OPEN, "No underlying server socket")
-	}
-	conn, err := p.listener.Accept()
-	if err != nil {
-		return nil, NewTTransportExceptionFromError(err)
-	}
-	return NewTSSLSocketFromConnTimeout(conn, p.cfg, p.clientTimeout), nil
-}
-
-// Checks whether the socket is listening.
-func (p *TSSLServerSocket) IsListening() bool {
-	return p.listener != nil
-}
-
-// Connects the socket, creating a new socket object if necessary.
-func (p *TSSLServerSocket) Open() error {
-	if p.IsListening() {
-		return NewTTransportException(ALREADY_OPEN, "Server socket already open")
-	}
-	if l, err := tls.Listen(p.addr.Network(), p.addr.String(), p.cfg); err != nil {
-		return err
-	} else {
-		p.listener = l
-	}
-	return nil
-}
-
-func (p *TSSLServerSocket) Addr() net.Addr {
-	return p.addr
-}
-
-func (p *TSSLServerSocket) Close() error {
-	defer func() {
-		p.listener = nil
-	}()
-	if p.IsListening() {
-		return p.listener.Close()
-	}
-	return nil
-}
-
-func (p *TSSLServerSocket) Interrupt() error {
-	p.interrupted = true
-	return nil
-}

vendor/github.com/apache/thrift/lib/go/thrift/ssl_socket.go

@@ -1,176 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"context"
-	"crypto/tls"
-	"net"
-	"time"
-)
-
-type TSSLSocket struct {
-	conn net.Conn
-	// hostPort contains host:port (e.g. "asdf.com:12345"). The field is
-	// only valid if addr is nil.
-	hostPort string
-	// addr is nil when hostPort is not "", and is only used when the
-	// TSSLSocket is constructed from a net.Addr.
-	addr    net.Addr
-	timeout time.Duration
-	cfg     *tls.Config
-}
-
-// NewTSSLSocket creates a net.Conn-backed TTransport, given a host and port and tls Configuration
-//
-// Example:
-// 	trans, err := thrift.NewTSSLSocket("localhost:9090", nil)
-func NewTSSLSocket(hostPort string, cfg *tls.Config) (*TSSLSocket, error) {
-	return NewTSSLSocketTimeout(hostPort, cfg, 0)
-}
-
-// NewTSSLSocketTimeout creates a net.Conn-backed TTransport, given a host and port
-// it also accepts a tls Configuration and a timeout as a time.Duration
-func NewTSSLSocketTimeout(hostPort string, cfg *tls.Config, timeout time.Duration) (*TSSLSocket, error) {
-	if cfg.MinVersion == 0 {
-		cfg.MinVersion = tls.VersionTLS10
-	}
-	return &TSSLSocket{hostPort: hostPort, timeout: timeout, cfg: cfg}, nil
-}
-
-// Creates a TSSLSocket from a net.Addr
-func NewTSSLSocketFromAddrTimeout(addr net.Addr, cfg *tls.Config, timeout time.Duration) *TSSLSocket {
-	return &TSSLSocket{addr: addr, timeout: timeout, cfg: cfg}
-}
-
-// Creates a TSSLSocket from an existing net.Conn
-func NewTSSLSocketFromConnTimeout(conn net.Conn, cfg *tls.Config, timeout time.Duration) *TSSLSocket {
-	return &TSSLSocket{conn: conn, addr: conn.RemoteAddr(), timeout: timeout, cfg: cfg}
-}
-
-// Sets the socket timeout
-func (p *TSSLSocket) SetTimeout(timeout time.Duration) error {
-	p.timeout = timeout
-	return nil
-}
-
-func (p *TSSLSocket) pushDeadline(read, write bool) {
-	var t time.Time
-	if p.timeout > 0 {
-		t = time.Now().Add(time.Duration(p.timeout))
-	}
-	if read && write {
-		p.conn.SetDeadline(t)
-	} else if read {
-		p.conn.SetReadDeadline(t)
-	} else if write {
-		p.conn.SetWriteDeadline(t)
-	}
-}
-
-// Connects the socket, creating a new socket object if necessary.
-func (p *TSSLSocket) Open() error {
-	var err error
-	// If we have a hostname, we need to pass the hostname to tls.Dial for
-	// certificate hostname checks.
-	if p.hostPort != "" {
-		if p.conn, err = tls.DialWithDialer(&net.Dialer{
-			Timeout: p.timeout}, "tcp", p.hostPort, p.cfg); err != nil {
-			return NewTTransportException(NOT_OPEN, err.Error())
-		}
-	} else {
-		if p.IsOpen() {
-			return NewTTransportException(ALREADY_OPEN, "Socket already connected.")
-		}
-		if p.addr == nil {
-			return NewTTransportException(NOT_OPEN, "Cannot open nil address.")
-		}
-		if len(p.addr.Network()) == 0 {
-			return NewTTransportException(NOT_OPEN, "Cannot open bad network name.")
-		}
-		if len(p.addr.String()) == 0 {
-			return NewTTransportException(NOT_OPEN, "Cannot open bad address.")
-		}
-		if p.conn, err = tls.DialWithDialer(&net.Dialer{
-			Timeout: p.timeout}, p.addr.Network(), p.addr.String(), p.cfg); err != nil {
-			return NewTTransportException(NOT_OPEN, err.Error())
-		}
-	}
-	return nil
-}
-
-// Retrieve the underlying net.Conn
-func (p *TSSLSocket) Conn() net.Conn {
-	return p.conn
-}
-
-// Returns true if the connection is open
-func (p *TSSLSocket) IsOpen() bool {
-	if p.conn == nil {
-		return false
-	}
-	return true
-}
-
-// Closes the socket.
-func (p *TSSLSocket) Close() error {
-	// Close the socket
-	if p.conn != nil {
-		err := p.conn.Close()
-		if err != nil {
-			return err
-		}
-		p.conn = nil
-	}
-	return nil
-}
-
-func (p *TSSLSocket) Read(buf []byte) (int, error) {
-	if !p.IsOpen() {
-		return 0, NewTTransportException(NOT_OPEN, "Connection not open")
-	}
-	p.pushDeadline(true, false)
-	n, err := p.conn.Read(buf)
-	return n, NewTTransportExceptionFromError(err)
-}
-
-func (p *TSSLSocket) Write(buf []byte) (int, error) {
-	if !p.IsOpen() {
-		return 0, NewTTransportException(NOT_OPEN, "Connection not open")
-	}
-	p.pushDeadline(false, true)
-	return p.conn.Write(buf)
-}
-
-func (p *TSSLSocket) Flush(ctx context.Context) error {
-	return nil
-}
-
-func (p *TSSLSocket) Interrupt() error {
-	if !p.IsOpen() {
-		return nil
-	}
-	return p.conn.Close()
-}
-
-func (p *TSSLSocket) RemainingBytes() (num_bytes uint64) {
-	const maxSize = ^uint64(0)
-	return maxSize // the thruth is, we just don't know unless framed is used
-}

vendor/github.com/apache/thrift/lib/go/thrift/transport.go

@@ -1,70 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"context"
-	"errors"
-	"io"
-)
-
-var errTransportInterrupted = errors.New("Transport Interrupted")
-
-type Flusher interface {
-	Flush() (err error)
-}
-
-type ContextFlusher interface {
-	Flush(ctx context.Context) (err error)
-}
-
-type ReadSizeProvider interface {
-	RemainingBytes() (num_bytes uint64)
-}
-
-// Encapsulates the I/O layer
-type TTransport interface {
-	io.ReadWriteCloser
-	ContextFlusher
-	ReadSizeProvider
-
-	// Opens the transport for communication
-	Open() error
-
-	// Returns true if the transport is open
-	IsOpen() bool
-}
-
-type stringWriter interface {
-	WriteString(s string) (n int, err error)
-}
-
-// This is "enchanced" transport with extra capabilities. You need to use one of these
-// to construct protocol.
-// Notably, TSocket does not implement this interface, and it is always a mistake to use
-// TSocket directly in protocol.
-type TRichTransport interface {
-	io.ReadWriter
-	io.ByteReader
-	io.ByteWriter
-	stringWriter
-	ContextFlusher
-	ReadSizeProvider
-}

vendor/github.com/apache/thrift/lib/go/thrift/transport_exception.go

@@ -1,90 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"errors"
-	"io"
-)
-
-type timeoutable interface {
-	Timeout() bool
-}
-
-// Thrift Transport exception
-type TTransportException interface {
-	TException
-	TypeId() int
-	Err() error
-}
-
-const (
-	UNKNOWN_TRANSPORT_EXCEPTION = 0
-	NOT_OPEN                    = 1
-	ALREADY_OPEN                = 2
-	TIMED_OUT                   = 3
-	END_OF_FILE                 = 4
-)
-
-type tTransportException struct {
-	typeId int
-	err    error
-}
-
-func (p *tTransportException) TypeId() int {
-	return p.typeId
-}
-
-func (p *tTransportException) Error() string {
-	return p.err.Error()
-}
-
-func (p *tTransportException) Err() error {
-	return p.err
-}
-
-func NewTTransportException(t int, e string) TTransportException {
-	return &tTransportException{typeId: t, err: errors.New(e)}
-}
-
-func NewTTransportExceptionFromError(e error) TTransportException {
-	if e == nil {
-		return nil
-	}
-
-	if t, ok := e.(TTransportException); ok {
-		return t
-	}
-
-	switch v := e.(type) {
-	case TTransportException:
-		return v
-	case timeoutable:
-		if v.Timeout() {
-			return &tTransportException{typeId: TIMED_OUT, err: e}
-		}
-	}
-
-	if e == io.EOF {
-		return &tTransportException{typeId: END_OF_FILE, err: e}
-	}
-
-	return &tTransportException{typeId: UNKNOWN_TRANSPORT_EXCEPTION, err: e}
-}

vendor/github.com/apache/thrift/lib/go/thrift/transport_exception_test.go

@@ -1,60 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"fmt"
-	"io"
-
-	"testing"
-)
-
-type timeout struct{ timedout bool }
-
-func (t *timeout) Timeout() bool {
-	return t.timedout
-}
-
-func (t *timeout) Error() string {
-	return fmt.Sprintf("Timeout: %v", t.timedout)
-}
-
-func TestTExceptionTimeout(t *testing.T) {
-	timeout := &timeout{true}
-	exception := NewTTransportExceptionFromError(timeout)
-	if timeout.Error() != exception.Error() {
-		t.Fatalf("Error did not match: expected %q, got %q", timeout.Error(), exception.Error())
-	}
-
-	if exception.TypeId() != TIMED_OUT {
-		t.Fatalf("TypeId was not TIMED_OUT: expected %v, got %v", TIMED_OUT, exception.TypeId())
-	}
-}
-
-func TestTExceptionEOF(t *testing.T) {
-	exception := NewTTransportExceptionFromError(io.EOF)
-	if io.EOF.Error() != exception.Error() {
-		t.Fatalf("Error did not match: expected %q, got %q", io.EOF.Error(), exception.Error())
-	}
-
-	if exception.TypeId() != END_OF_FILE {
-		t.Fatalf("TypeId was not END_OF_FILE: expected %v, got %v", END_OF_FILE, exception.TypeId())
-	}
-}

vendor/github.com/apache/thrift/lib/go/thrift/transport_factory.go

@@ -1,39 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-// Factory class used to create wrapped instance of Transports.
-// This is used primarily in servers, which get Transports from
-// a ServerTransport and then may want to mutate them (i.e. create
-// a BufferedTransport from the underlying base transport)
-type TTransportFactory interface {
-	GetTransport(trans TTransport) (TTransport, error)
-}
-
-type tTransportFactory struct{}
-
-// Return a wrapped instance of the base Transport.
-func (p *tTransportFactory) GetTransport(trans TTransport) (TTransport, error) {
-	return trans, nil
-}
-
-func NewTTransportFactory() TTransportFactory {
-	return &tTransportFactory{}
-}

vendor/github.com/apache/thrift/lib/go/thrift/transport_test.go

@@ -1,177 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package thrift
-
-import (
-	"context"
-	"io"
-	"net"
-	"strconv"
-	"testing"
-)
-
-const TRANSPORT_BINARY_DATA_SIZE = 4096
-
-var (
-	transport_bdata  []byte // test data for writing; same as data
-	transport_header map[string]string
-)
-
-func init() {
-	transport_bdata = make([]byte, TRANSPORT_BINARY_DATA_SIZE)
-	for i := 0; i < TRANSPORT_BINARY_DATA_SIZE; i++ {
-		transport_bdata[i] = byte((i + 'a') % 255)
-	}
-	transport_header = map[string]string{"key": "User-Agent",
-		"value": "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/32.0.1667.0 Safari/537.36"}
-}
-
-func TransportTest(t *testing.T, writeTrans TTransport, readTrans TTransport) {
-	buf := make([]byte, TRANSPORT_BINARY_DATA_SIZE)
-	if !writeTrans.IsOpen() {
-		t.Fatalf("Transport %T not open: %s", writeTrans, writeTrans)
-	}
-	if !readTrans.IsOpen() {
-		t.Fatalf("Transport %T not open: %s", readTrans, readTrans)
-	}
-	_, err := writeTrans.Write(transport_bdata)
-	if err != nil {
-		t.Fatalf("Transport %T cannot write binary data of length %d: %s", writeTrans, len(transport_bdata), err)
-	}
-	err = writeTrans.Flush(context.Background())
-	if err != nil {
-		t.Fatalf("Transport %T cannot flush write of binary data: %s", writeTrans, err)
-	}
-	n, err := io.ReadFull(readTrans, buf)
-	if err != nil {
-		t.Errorf("Transport %T cannot read binary data of length %d: %s", readTrans, TRANSPORT_BINARY_DATA_SIZE, err)
-	}
-	if n != TRANSPORT_BINARY_DATA_SIZE {
-		t.Errorf("Transport %T read only %d instead of %d bytes of binary data", readTrans, n, TRANSPORT_BINARY_DATA_SIZE)
-	}
-	for k, v := range buf {
-		if v != transport_bdata[k] {
-			t.Fatalf("Transport %T read %d instead of %d for index %d of binary data 2", readTrans, v, transport_bdata[k], k)
-		}
-	}
-	_, err = writeTrans.Write(transport_bdata)
-	if err != nil {
-		t.Fatalf("Transport %T cannot write binary data 2 of length %d: %s", writeTrans, len(transport_bdata), err)
-	}
-	err = writeTrans.Flush(context.Background())
-	if err != nil {
-		t.Fatalf("Transport %T cannot flush write binary data 2: %s", writeTrans, err)
-	}
-	buf = make([]byte, TRANSPORT_BINARY_DATA_SIZE)
-	read := 1
-	for n = 0; n < TRANSPORT_BINARY_DATA_SIZE && read != 0; {
-		read, err = readTrans.Read(buf[n:])
-		if err != nil {
-			t.Errorf("Transport %T cannot read binary data 2 of total length %d from offset %d: %s", readTrans, TRANSPORT_BINARY_DATA_SIZE, n, err)
-		}
-		n += read
-	}
-	if n != TRANSPORT_BINARY_DATA_SIZE {
-		t.Errorf("Transport %T read only %d instead of %d bytes of binary data 2", readTrans, n, TRANSPORT_BINARY_DATA_SIZE)
-	}
-	for k, v := range buf {
-		if v != transport_bdata[k] {
-			t.Fatalf("Transport %T read %d instead of %d for index %d of binary data 2", readTrans, v, transport_bdata[k], k)
-		}
-	}
-}
-
-func TransportHeaderTest(t *testing.T, writeTrans TTransport, readTrans TTransport) {
-	buf := make([]byte, TRANSPORT_BINARY_DATA_SIZE)
-	if !writeTrans.IsOpen() {
-		t.Fatalf("Transport %T not open: %s", writeTrans, writeTrans)
-	}
-	if !readTrans.IsOpen() {
-		t.Fatalf("Transport %T not open: %s", readTrans, readTrans)
-	}
-	// Need to assert type of TTransport to THttpClient to expose the Setter
-	httpWPostTrans := writeTrans.(*THttpClient)
-	httpWPostTrans.SetHeader(transport_header["key"], transport_header["value"])
-
-	_, err := writeTrans.Write(transport_bdata)
-	if err != nil {
-		t.Fatalf("Transport %T cannot write binary data of length %d: %s", writeTrans, len(transport_bdata), err)
-	}
-	err = writeTrans.Flush(context.Background())
-	if err != nil {
-		t.Fatalf("Transport %T cannot flush write of binary data: %s", writeTrans, err)
-	}
-	// Need to assert type of TTransport to THttpClient to expose the Getter
-	httpRPostTrans := readTrans.(*THttpClient)
-	readHeader := httpRPostTrans.GetHeader(transport_header["key"])
-	if err != nil {
-		t.Errorf("Transport %T cannot read HTTP Header Value", httpRPostTrans)
-	}
-
-	if transport_header["value"] != readHeader {
-		t.Errorf("Expected HTTP Header Value %s, got %s", transport_header["value"], readHeader)
-	}
-	n, err := io.ReadFull(readTrans, buf)
-	if err != nil {
-		t.Errorf("Transport %T cannot read binary data of length %d: %s", readTrans, TRANSPORT_BINARY_DATA_SIZE, err)
-	}
-	if n != TRANSPORT_BINARY_DATA_SIZE {
-		t.Errorf("Transport %T read only %d instead of %d bytes of binary data", readTrans, n, TRANSPORT_BINARY_DATA_SIZE)
-	}
-	for k, v := range buf {
-		if v != transport_bdata[k] {
-			t.Fatalf("Transport %T read %d instead of %d for index %d of binary data 2", readTrans, v, transport_bdata[k], k)
-		}
-	}
-}
-
-func CloseTransports(t *testing.T, readTrans TTransport, writeTrans TTransport) {
-	err := readTrans.Close()
-	if err != nil {
-		t.Errorf("Transport %T cannot close read transport: %s", readTrans, err)
-	}
-	if writeTrans != readTrans {
-		err = writeTrans.Close()
-		if err != nil {
-			t.Errorf("Transport %T cannot close write transport: %s", writeTrans, err)
-		}
-	}
-}
-
-func FindAvailableTCPServerPort(startPort int) (net.Addr, error) {
-	for i := startPort; i < 65535; i++ {
-		s := "127.0.0.1:" + strconv.Itoa(i)
-		l, err := net.Listen("tcp", s)
-		if err == nil {
-			l.Close()
-			return net.ResolveTCPAddr("tcp", s)
-		}
-	}
-	return nil, NewTTransportException(UNKNOWN_TRANSPORT_EXCEPTION, "Could not find available server port")
-}
-
-func valueInSlice(value string, slice []string) bool {
-	for _, v := range slice {
-		if value == v {
-			return true
-		}
-	}
-	return false
-}