Public release of gorealis
This commit is contained in:
Renan DelValle
commit
327c6c369d
82 changed files with 45075 additions and 0 deletions
201
LICENSE
Normal file
201
LICENSE
Normal file
|
|
@ -0,0 +1,201 @@
|
|||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "{}"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright {yyyy} {name of copyright owner}
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
133
README.md
Normal file
133
README.md
Normal file
|
|
@ -0,0 +1,133 @@
|
|||
# GoRealis
|
||||
|
||||
Go library for communicating with Apache Aurora.
|
||||
Named after the northern lights (Aurora Borealis).
|
||||
|
||||
## Usage
|
||||
|
||||
### Using the Sample client with Thermos
|
||||
Clone Aurora:
|
||||
```
|
||||
$ git clone git://git.apache.org/aurora.git
|
||||
```
|
||||
|
||||
Bring up the vagrant image:
|
||||
```
|
||||
$ cd aurora
|
||||
$ vagrant up
|
||||
```
|
||||
|
||||
Download and run the Client to create a Thermos Job:
|
||||
```
|
||||
$ go get github.com/rdelval/gorealis
|
||||
$ go run $GOPATH/src/github.com/rdelval/gorealis/examples/Client.go -executor=thermos -url=http://192.168.33.7:8081 -cmd=create
|
||||
```
|
||||
|
||||
### Using the Sample client with Docker Compose executor
|
||||
|
||||
Clone modified version of Aurora repo and checkout the right branch:
|
||||
```
|
||||
$ git clone git@github.com:rdelval/aurora.git
|
||||
$ git checkout DockerComposeExecutor
|
||||
```
|
||||
|
||||
Bring up the vagrant image:
|
||||
```
|
||||
$ cd aurora
|
||||
$ vagrant up
|
||||
```
|
||||
|
||||
Download and run the Client to create a Docker-Compose Job:
|
||||
```
|
||||
$ go get github.com/rdelval/gorealis
|
||||
$ go run $GOPATH/src/github.com/rdelval/gorealis/examples/Client.go -executor=compose -url=http://192.168.33.7:8081 -cmd=create
|
||||
```
|
||||
From the [Aurora web UI](http://192.168.33.7:8081/scheduler/vagrant/prod/docker-compose/0), create struct dump by clicking on the task ID.
|
||||
In the struct dump, find the port assigned to the task (named "port0").
|
||||
|
||||
Navigate to the 192.168.33.7:`<assigned port>`. Currently the redis image being deployed is broken, so an error is expected.
|
||||
If the page is not found, wait a few minutes while the docker image is downloaded and the container is deployed.
|
||||
|
||||
Finally, terminate the job:
|
||||
```
|
||||
$ go run $GOPATH/src/github.com/rdelval/gorealis.git/examples/Client.go -executor=compose -url=http://192.168.33.7:8081 -cmd=kill
|
||||
```
|
||||
|
||||
### Leveraging the library
|
||||
Commands available: create, kill, restart
|
||||
|
||||
Create a default configuration file (alternatively, manually create your own Config):
|
||||
```
|
||||
config, err := realis.NewDefaultConfig(*url)
|
||||
```
|
||||
|
||||
Create a new Realis struct by passing the configuration struct in:
|
||||
```
|
||||
r := realis.NewClient(config)
|
||||
defer r.Close()
|
||||
```
|
||||
|
||||
Construct a job using an AuroraJob struct.
|
||||
```
|
||||
job = realis.NewJob().SetEnvironment("prod").
|
||||
SetRole("vagrant").
|
||||
SetName("hello_world_from_gorealis").
|
||||
SetExecutorName("docker-compose-executor").
|
||||
SetExecutorData("{}").
|
||||
SetNumCpus(1).
|
||||
SetRam(64).
|
||||
SetDisk(100).
|
||||
SetIsService(false).
|
||||
SetInstanceCount(1).
|
||||
AddPorts(1).
|
||||
AddLabel("fileName", "sample-app/sample-app.yml").
|
||||
AddURI("https://dl.bintray.com/rdelvalle/mesos-compose-executor/sample-app.tar.gz", true, true)
|
||||
|
||||
```
|
||||
|
||||
Use client to send a job to Aurora:
|
||||
```
|
||||
r.CreateJob(job)
|
||||
```
|
||||
|
||||
Killing an Aurora Job:
|
||||
```
|
||||
r.KillJob(job.GetKey())
|
||||
```
|
||||
|
||||
Restarting all instances of an Aurora Job:
|
||||
```
|
||||
r.RestartJob(job.GetKey())
|
||||
```
|
||||
|
||||
Adding instances (based on config of instance 0) to Aurora:
|
||||
```
|
||||
r.AddInstances(job.GetKey(), 5)
|
||||
```
|
||||
|
||||
Updating the job configuration of a service job:
|
||||
```
|
||||
updateJob := realis.NewUpdateJob(job)
|
||||
updateJob.SetInstanceCount(1)
|
||||
updateJob.SetRam(128)
|
||||
|
||||
msg, err := r.UpdateJob(updateJob, "")
|
||||
```
|
||||
|
||||
### Methods:
|
||||
|
||||
|Method | Arguments | Description|
|
||||
|----------|------------|------------|
|
||||
|CreateJob | `*Job` | Sends a job create request to Apache Aurora |
|
||||
|KillJob | `*aurora.JobKey` | Attempts to kill all active instances running in Aurora. Only needs environment, role, name |
|
||||
|RestartJob| `*aurora.JobKey` | Attempts to restart all active instances running in Aurora |
|
||||
|AddInstances|`*aurora.JobKey`, `int32`| Launches the specified number of new instances based on existing job config |
|
||||
|StartUpdateJob|`*UpdateJob`, `string`| Updates a service job with a new configuration |
|
||||
|AbortUpdateJob|`*aurora.Jobkey`, `string`, `string`| Abort the job update that matches the ID |
|
||||
|
||||
## To Do
|
||||
* Create or import a custom transport that uses https://github.com/jmcvetta/napping to improve efficiency
|
||||
* Allow library to use ZK to find the master
|
||||
|
||||
## Contributions
|
||||
Contributions are very much welcome. Please raise an issue so that the contribution may be discussed before it's made.
|
||||
1204
auroraAPI.thrift
Normal file
1204
auroraAPI.thrift
Normal file
File diff suppressed because it is too large
Load diff
148
examples/Client.go
Normal file
148
examples/Client.go
Normal file
|
|
@ -0,0 +1,148 @@
|
|||
/**
|
||||
* 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 main
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"gen-go/apache/aurora"
|
||||
"github.com/rdelval/gorealis"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
cmd := flag.String("cmd", "", "Action to execute on Apache Aurora Sched")
|
||||
executor := flag.String("executor", "thermos", "Executor to use, thermos by default")
|
||||
url := flag.String("url", "", "URL at which the Apache Aurora Scheduler exists [url]:[port]")
|
||||
updateId := flag.String("updateId", "", "Update ID to operate on")
|
||||
flag.Parse()
|
||||
|
||||
//Create new configuration with default transport layer
|
||||
config, err := realis.NewDefaultConfig(*url)
|
||||
if err != nil {
|
||||
fmt.Print(err)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Needed for authorization for Vagrant
|
||||
realis.AddBasicAuth(&config, "aurora", "secret")
|
||||
r := realis.NewClient(config)
|
||||
defer r.Close()
|
||||
|
||||
var job *realis.Job
|
||||
|
||||
switch *executor {
|
||||
case "thermos":
|
||||
payload, err := ioutil.ReadFile("thermos_payload.json")
|
||||
|
||||
if err != nil {
|
||||
fmt.Print("Error reading json config file: ", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
job = realis.NewJob().SetEnvironment("prod").
|
||||
SetRole("vagrant").
|
||||
SetName("hello_world_from_gorealis").
|
||||
SetExecutorName(aurora.AURORA_EXECUTOR_NAME).
|
||||
SetExecutorData(string(payload)).
|
||||
SetNumCpus(1).
|
||||
SetRam(64).
|
||||
SetDisk(100).
|
||||
SetIsService(true).
|
||||
SetInstanceCount(1).
|
||||
AddPorts(1)
|
||||
break
|
||||
case "compose":
|
||||
job = realis.NewJob().SetEnvironment("prod").
|
||||
SetRole("vagrant").
|
||||
SetName("docker-compose").
|
||||
SetExecutorName("docker-compose-executor").
|
||||
SetExecutorData("{}").
|
||||
SetNumCpus(1).
|
||||
SetRam(64).
|
||||
SetDisk(100).
|
||||
SetIsService(false).
|
||||
SetInstanceCount(1).
|
||||
AddPorts(1).
|
||||
AddLabel("fileName", "sample-app/sample-app.yml").
|
||||
AddURI("https://dl.bintray.com/rdelvalle/mesos-compose-executor/sample-app.tar.gz", true, true)
|
||||
break
|
||||
default:
|
||||
fmt.Println("Only thermos and compose are supported for now")
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
switch *cmd {
|
||||
case "create":
|
||||
fmt.Println("Creating job")
|
||||
msg, err := r.CreateJob(job)
|
||||
if err != nil {
|
||||
fmt.Print(err)
|
||||
}
|
||||
|
||||
fmt.Print(msg)
|
||||
break
|
||||
case "kill":
|
||||
fmt.Println("Killing job")
|
||||
|
||||
msg, err := r.KillJob(job.GetJobKey())
|
||||
if err != nil {
|
||||
fmt.Print(err)
|
||||
}
|
||||
|
||||
fmt.Print(msg)
|
||||
break
|
||||
case "restart":
|
||||
fmt.Println("Restarting job")
|
||||
msg, err := r.RestartJob(job.GetJobKey())
|
||||
if err != nil {
|
||||
fmt.Print(err)
|
||||
}
|
||||
|
||||
fmt.Print(msg)
|
||||
break
|
||||
case "flexUp":
|
||||
fmt.Println("Flexing up job")
|
||||
msg, err := r.AddInstances(job.GetJobKey(), 5)
|
||||
if err != nil {
|
||||
fmt.Print(err)
|
||||
}
|
||||
fmt.Print(msg)
|
||||
break
|
||||
case "update":
|
||||
fmt.Println("Updating a job with a new name")
|
||||
updateJob := realis.NewUpdateJob(job)
|
||||
|
||||
updateJob.SetInstanceCount(3).SetRam(128)
|
||||
|
||||
msg, err := r.StartJobUpdate(updateJob, "")
|
||||
if err != nil {
|
||||
fmt.Print(err)
|
||||
}
|
||||
fmt.Print(msg)
|
||||
break
|
||||
case "abortUpdate":
|
||||
fmt.Println("Abort update")
|
||||
msg, err := r.AbortJobUpdate(job.GetJobKey(), *updateId, "")
|
||||
if err != nil {
|
||||
fmt.Print(err)
|
||||
}
|
||||
fmt.Print(msg)
|
||||
break
|
||||
default:
|
||||
fmt.Println("Only Create, Kill, and Restart are supported now")
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
62
examples/thermos_payload.json
Normal file
62
examples/thermos_payload.json
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
{
|
||||
"environment": "prod",
|
||||
"health_check_config": {
|
||||
"initial_interval_secs": 15.0,
|
||||
"health_checker": {
|
||||
"http": {
|
||||
"expected_response_code": 0,
|
||||
"endpoint": "/health",
|
||||
"expected_response": "ok"
|
||||
}
|
||||
},
|
||||
"interval_secs": 10.0,
|
||||
"timeout_secs": 1.0,
|
||||
"max_consecutive_failures": 0
|
||||
},
|
||||
"name": "hello_world_from_gorealis",
|
||||
"service": false,
|
||||
"max_task_failures": 1,
|
||||
"cron_collision_policy": "KILL_EXISTING",
|
||||
"enable_hooks": false,
|
||||
"cluster": "devcluster",
|
||||
"task": {
|
||||
"processes": [
|
||||
{
|
||||
"daemon": false,
|
||||
"name": "hello",
|
||||
"ephemeral": false,
|
||||
"max_failures": 1,
|
||||
"min_duration": 5,
|
||||
"cmdline": "\n while true; do\n echo hello world from GoRealis\n sleep 10\n done\n ",
|
||||
"final": false
|
||||
}
|
||||
],
|
||||
"name": "hello",
|
||||
"finalization_wait": 30,
|
||||
"max_failures": 1,
|
||||
"max_concurrency": 0,
|
||||
"resources": {
|
||||
"gpu": 0,
|
||||
"disk": 134217728,
|
||||
"ram": 134217728,
|
||||
"cpu": 1.0
|
||||
},
|
||||
"constraints": [
|
||||
{
|
||||
"order": [
|
||||
"hello"
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
"production": false,
|
||||
"role": "vagrant",
|
||||
"lifecycle": {
|
||||
"http": {
|
||||
"graceful_shutdown_endpoint": "/quitquitquit",
|
||||
"port": "health",
|
||||
"shutdown_endpoint": "/abortabortabort"
|
||||
}
|
||||
},
|
||||
"priority": 0
|
||||
}
|
||||
11
generateBindings.sh
Executable file
11
generateBindings.sh
Executable file
|
|
@ -0,0 +1,11 @@
|
|||
#! /bin/bash
|
||||
|
||||
THRIFT_VER=0.9.3
|
||||
|
||||
if [[ $(thrift -version | grep -e $THRIFT_VER -c) -ne 1 ]]; then
|
||||
echo "Warning: This wrapper has only been tested with version" $THRIFT_VER;
|
||||
fi
|
||||
|
||||
echo "Generating bindings and placing them in the vendor folder...";
|
||||
thrift -o vendor/ -r -gen go:package=apache.aurora auroraAPI.thrift;
|
||||
echo "Done";
|
||||
194
job.go
Normal file
194
job.go
Normal file
|
|
@ -0,0 +1,194 @@
|
|||
/**
|
||||
* 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 (
|
||||
"gen-go/apache/aurora"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
type Job struct {
|
||||
jobConfig *aurora.JobConfiguration
|
||||
numCpus *aurora.Resource
|
||||
ramMb *aurora.Resource
|
||||
diskMb *aurora.Resource
|
||||
portCount int
|
||||
}
|
||||
|
||||
type CreateJobBuilder struct {
|
||||
jobConfig *aurora.JobConfiguration
|
||||
jobKey *aurora.JobKey
|
||||
taskConfig *aurora.TaskConfig
|
||||
numCpus *aurora.Resource
|
||||
ramMb *aurora.Resource
|
||||
diskMb *aurora.Resource
|
||||
}
|
||||
|
||||
func NewJob() *Job {
|
||||
jobConfig := aurora.NewJobConfiguration()
|
||||
taskConfig := aurora.NewTaskConfig()
|
||||
jobKey := aurora.NewJobKey()
|
||||
|
||||
//Job Config
|
||||
jobConfig.Key = jobKey
|
||||
jobConfig.TaskConfig = taskConfig
|
||||
|
||||
//Task Config
|
||||
taskConfig.Job = jobKey
|
||||
taskConfig.Container = aurora.NewContainer()
|
||||
taskConfig.Container.Mesos = aurora.NewMesosContainer()
|
||||
taskConfig.ExecutorConfig = aurora.NewExecutorConfig()
|
||||
taskConfig.MesosFetcherUris = make(map[*aurora.MesosFetcherURI]bool)
|
||||
taskConfig.Metadata = make(map[*aurora.Metadata]bool)
|
||||
taskConfig.Constraints = make(map[*aurora.Constraint]bool)
|
||||
|
||||
//Resources
|
||||
numCpus := aurora.NewResource()
|
||||
ramMb := aurora.NewResource()
|
||||
diskMb := aurora.NewResource()
|
||||
|
||||
taskConfig.Resources = make(map[*aurora.Resource]bool)
|
||||
taskConfig.Resources[numCpus] = true
|
||||
taskConfig.Resources[ramMb] = true
|
||||
taskConfig.Resources[diskMb] = true
|
||||
|
||||
return &Job{jobConfig, numCpus, ramMb, diskMb, 0}
|
||||
}
|
||||
|
||||
func (a *Job) SetEnvironment(env string) *Job {
|
||||
a.jobConfig.Key.Environment = env
|
||||
return a
|
||||
}
|
||||
|
||||
func (a *Job) SetRole(role string) *Job {
|
||||
a.jobConfig.Key.Role = role
|
||||
|
||||
//Will be deprecated
|
||||
identity := &aurora.Identity{role}
|
||||
a.jobConfig.Owner = identity
|
||||
a.jobConfig.TaskConfig.Owner = identity
|
||||
return a
|
||||
}
|
||||
|
||||
func (a *Job) SetName(name string) *Job {
|
||||
a.jobConfig.Key.Name = name
|
||||
return a
|
||||
}
|
||||
|
||||
func (a *Job) SetExecutorName(name string) *Job {
|
||||
a.jobConfig.TaskConfig.ExecutorConfig.Name = name
|
||||
return a
|
||||
}
|
||||
|
||||
func (a *Job) SetExecutorData(data string) *Job {
|
||||
a.jobConfig.TaskConfig.ExecutorConfig.Data = data
|
||||
return a
|
||||
}
|
||||
|
||||
func (a *Job) SetNumCpus(cpus float64) *Job {
|
||||
a.numCpus.NumCpus = &cpus
|
||||
a.jobConfig.TaskConfig.NumCpus = cpus //Will be deprecated soon
|
||||
|
||||
return a
|
||||
}
|
||||
|
||||
func (a *Job) SetRam(ram int64) *Job {
|
||||
a.ramMb.RamMb = &ram
|
||||
a.jobConfig.TaskConfig.RamMb = ram //Will be deprecated soon
|
||||
|
||||
return a
|
||||
}
|
||||
|
||||
func (a *Job) SetDisk(disk int64) *Job {
|
||||
a.diskMb.DiskMb = &disk
|
||||
a.jobConfig.TaskConfig.DiskMb = disk //Will be deprecated
|
||||
|
||||
return a
|
||||
}
|
||||
|
||||
func (a *Job) SetMaxFailure(maxFail int32) *Job {
|
||||
a.jobConfig.TaskConfig.MaxTaskFailures = maxFail
|
||||
return a
|
||||
}
|
||||
|
||||
func (a *Job) SetInstanceCount(instCount int32) *Job {
|
||||
a.jobConfig.InstanceCount = instCount
|
||||
return a
|
||||
}
|
||||
|
||||
func (a *Job) SetIsService(isService bool) *Job {
|
||||
a.jobConfig.TaskConfig.IsService = isService
|
||||
return a
|
||||
}
|
||||
|
||||
func (a *Job) GetJobKey() *aurora.JobKey {
|
||||
return a.jobConfig.Key
|
||||
}
|
||||
|
||||
func (a *Job) AddURI(value string, extract bool, cache bool) *Job {
|
||||
a.jobConfig.TaskConfig.MesosFetcherUris[&aurora.MesosFetcherURI{value, &extract, &cache}] = true
|
||||
return a
|
||||
}
|
||||
|
||||
func (a *Job) AddURIs(extract bool, cache bool, values ...string) *Job {
|
||||
for _, value := range values {
|
||||
a.jobConfig.TaskConfig.MesosFetcherUris[&aurora.MesosFetcherURI{value, &extract, &cache}] = true
|
||||
}
|
||||
return a
|
||||
}
|
||||
|
||||
// Note: By default Aurora will add the prefix "org.apache.aurora.metadata." to the beginning of each key
|
||||
func (a *Job) AddLabel(key string, value string) *Job {
|
||||
a.jobConfig.TaskConfig.Metadata[&aurora.Metadata{key, value}] = true
|
||||
return a
|
||||
}
|
||||
|
||||
//Each port is equivalent to Marathon's 0 port
|
||||
func (a *Job) AddPorts(num int) *Job {
|
||||
start := a.portCount
|
||||
a.portCount += num
|
||||
for i := start; i < a.portCount; i++ {
|
||||
portName := "port" + strconv.Itoa(i)
|
||||
a.jobConfig.TaskConfig.Resources[&aurora.Resource{NamedPort: &portName}] = true
|
||||
}
|
||||
|
||||
return a
|
||||
}
|
||||
|
||||
// Add a Value constraint,
|
||||
// name - Mesos slave attribute that the constraint is matched against.
|
||||
// If negated = true , treat this as a 'not' - to avoid specific values.
|
||||
func (a *Job) AddValueConstraint(name string,
|
||||
negated bool,
|
||||
values ...string) *Job {
|
||||
|
||||
constraintValues := make(map[string]bool)
|
||||
for _, value := range values {
|
||||
constraintValues[value] = true
|
||||
}
|
||||
a.jobConfig.TaskConfig.Constraints[&aurora.Constraint{name,
|
||||
&aurora.TaskConstraint{&aurora.ValueConstraint{negated, constraintValues}, nil}}] = true
|
||||
|
||||
return a
|
||||
}
|
||||
|
||||
// From Aurora Docs: A constraint the specifies the maximum number of active tasks on a host with
|
||||
// a matching attribute that may be scheduled simultaneously.
|
||||
func (a *Job) AddLimitConstraint(name string, limit int32) *Job {
|
||||
|
||||
a.jobConfig.TaskConfig.Constraints[&aurora.Constraint{name,
|
||||
&aurora.TaskConstraint{nil, &aurora.LimitConstraint{limit}}}] = true
|
||||
|
||||
return a
|
||||
}
|
||||
205
realis.go
Normal file
205
realis.go
Normal file
|
|
@ -0,0 +1,205 @@
|
|||
/**
|
||||
* 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 provides the ability to use Thrift API to communicate with Apache Aurora.
|
||||
package realis
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"gen-go/apache/aurora"
|
||||
"git.apache.org/thrift.git/lib/go/thrift"
|
||||
"github.com/pkg/errors"
|
||||
"net/http"
|
||||
"net/http/cookiejar"
|
||||
"os"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Realis struct {
|
||||
client *aurora.AuroraSchedulerManagerClient
|
||||
}
|
||||
|
||||
// Wrap object to provide future flexibility
|
||||
type RealisConfig struct {
|
||||
transport thrift.TTransport
|
||||
}
|
||||
|
||||
// Create a new Client
|
||||
func NewClient(config RealisConfig) *Realis {
|
||||
|
||||
httpTrans := (config.transport).(*thrift.THttpClient)
|
||||
httpTrans.SetHeader("User-Agent", "GoRealis v0.1")
|
||||
|
||||
// Aurora can only communicate in JSON, leave it here as default
|
||||
protocolFactory := thrift.NewTJSONProtocolFactory()
|
||||
|
||||
return &Realis{client: aurora.NewAuroraSchedulerManagerClientFactory(config.transport, protocolFactory)}
|
||||
}
|
||||
|
||||
// Create a default configuration of the transport layer, requires a URL
|
||||
func NewDefaultConfig(url string) (RealisConfig, error) {
|
||||
jar, err := cookiejar.New(nil)
|
||||
|
||||
if err != nil {
|
||||
return RealisConfig{}, errors.Wrap(err, "Error creating Cookie Jar")
|
||||
}
|
||||
|
||||
//Custom client to timeout after 10 seconds to avoid hanging
|
||||
trans, err := thrift.NewTHttpPostClientWithOptions(url+"/api",
|
||||
thrift.THttpClientOptions{Client: &http.Client{Timeout: time.Second * 10, Jar: jar}})
|
||||
|
||||
if err != nil {
|
||||
return RealisConfig{}, errors.Wrap(err, "Error creating transport")
|
||||
}
|
||||
|
||||
if err := trans.Open(); err != nil {
|
||||
fmt.Fprintln(os.Stderr)
|
||||
return RealisConfig{}, errors.Wrapf(err, "Error opening connection to %s", url)
|
||||
}
|
||||
|
||||
return RealisConfig{transport: trans}, nil
|
||||
|
||||
}
|
||||
|
||||
// Helper function to add basic authorization needed to communicate with Apache Aurora
|
||||
func AddBasicAuth(config *RealisConfig, username string, password string) {
|
||||
httpTrans := (config.transport).(*thrift.THttpClient)
|
||||
httpTrans.SetHeader("Authorization", "Basic "+basicAuth(username, password))
|
||||
}
|
||||
|
||||
func basicAuth(username, password string) string {
|
||||
auth := username + ":" + password
|
||||
return base64.StdEncoding.EncodeToString([]byte(auth))
|
||||
}
|
||||
|
||||
// Releases resources associated with the realis client
|
||||
func (r *Realis) Close() {
|
||||
r.client.Transport.Close()
|
||||
}
|
||||
|
||||
// Uses predefined set of states to retrieve a set of active jobs in Apache Aurora
|
||||
func (r *Realis) getActiveTaskIds(key *aurora.JobKey) (map[int32]bool, error) {
|
||||
taskQ := &aurora.TaskQuery{Role: key.Role,
|
||||
Environment: key.Environment,
|
||||
JobName: key.Name,
|
||||
Statuses: aurora.ACTIVE_STATES}
|
||||
|
||||
response, err := r.client.GetTasksWithoutConfigs(taskQ)
|
||||
if err != nil {
|
||||
return nil, errors.Wrap(err, "Error querying Aurora Scheduler")
|
||||
}
|
||||
|
||||
tasks := response.GetResult_().GetScheduleStatusResult_().GetTasks()
|
||||
|
||||
jobTaskIds := make(map[int32]bool)
|
||||
for _, task := range tasks {
|
||||
jobTaskIds[task.GetAssignedTask().GetInstanceId()] = true
|
||||
}
|
||||
|
||||
return jobTaskIds, nil
|
||||
}
|
||||
|
||||
// Sends a kill message to the scheduler for all active tasks under a job
|
||||
func (r *Realis) KillJob(key *aurora.JobKey) (string, error) {
|
||||
|
||||
taskIds, err := r.getActiveTaskIds(key)
|
||||
if err != nil {
|
||||
return "", errors.Wrap(err, "Could not retrieve relevant task IDs")
|
||||
}
|
||||
|
||||
if len(taskIds) > 0 {
|
||||
response, err := r.client.KillTasks(key, taskIds)
|
||||
|
||||
if err != nil {
|
||||
return "", errors.Wrap(err, "Error sending Kill command to Aurora Scheduler")
|
||||
}
|
||||
return response.String(), nil
|
||||
} else {
|
||||
return "No tasks in the Active state.", nil
|
||||
}
|
||||
}
|
||||
|
||||
// Sends a create job message to the scheduler with a specific job configuration
|
||||
func (r *Realis) CreateJob(auroraJob *Job) (string, error) {
|
||||
response, err := r.client.CreateJob(auroraJob.jobConfig)
|
||||
|
||||
if err != nil {
|
||||
return "", errors.Wrap(err, "Error sending Create command to Aurora Scheduler")
|
||||
}
|
||||
|
||||
return response.String(), nil
|
||||
}
|
||||
|
||||
// Restarts all active tasks under a job configuration
|
||||
func (r *Realis) RestartJob(key *aurora.JobKey) (string, error) {
|
||||
|
||||
taskIds, err := r.getActiveTaskIds(key)
|
||||
if err != nil {
|
||||
return "", errors.Wrap(err, "Could not retrieve relevant task IDs")
|
||||
}
|
||||
|
||||
if len(taskIds) > 0 {
|
||||
response, err := r.client.RestartShards(key, taskIds)
|
||||
|
||||
if err != nil {
|
||||
return "", errors.Wrap(err, "Error sending Restart command to Aurora Scheduler")
|
||||
}
|
||||
|
||||
return response.String(), nil
|
||||
} else {
|
||||
return "No tasks in the Active state.", nil
|
||||
}
|
||||
}
|
||||
|
||||
// Update all tasks under a job configuration
|
||||
func (r *Realis) StartJobUpdate(updateJob *UpdateJob, message string) (string, error) {
|
||||
|
||||
response, err := r.client.StartJobUpdate(updateJob.req, message)
|
||||
|
||||
if err != nil {
|
||||
return "", errors.Wrap(err, "Error sending StartJobUpdate command to Aurora Scheduler")
|
||||
}
|
||||
|
||||
return response.String(), nil
|
||||
}
|
||||
|
||||
func (r *Realis) AbortJobUpdate(
|
||||
key *aurora.JobKey,
|
||||
updateId string,
|
||||
message string) (string, error) {
|
||||
|
||||
response, err := r.client.AbortJobUpdate(&aurora.JobUpdateKey{key, updateId}, message)
|
||||
|
||||
if err != nil {
|
||||
return "", errors.Wrap(err, "Error sending AbortJobUpdate command to Aurora Scheduler")
|
||||
}
|
||||
|
||||
return response.String(), nil
|
||||
}
|
||||
|
||||
// Scale up the number of instances under a job configuration
|
||||
func (r *Realis) AddInstances(key *aurora.JobKey, count int32) (string, error) {
|
||||
|
||||
//Scale up using the config from task 0. All tasks should be homogeneous.
|
||||
instKey := &aurora.InstanceKey{key, 0}
|
||||
|
||||
response, err := r.client.AddInstances(instKey, count)
|
||||
|
||||
if err != nil {
|
||||
return "", errors.Wrap(err, "Error sending AddInstances command to Aurora Scheduler")
|
||||
}
|
||||
|
||||
return response.String(), nil
|
||||
|
||||
}
|
||||
84
updatejob.go
Normal file
84
updatejob.go
Normal file
|
|
@ -0,0 +1,84 @@
|
|||
/**
|
||||
* 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 "gen-go/apache/aurora"
|
||||
|
||||
type UpdateJob struct {
|
||||
*Job //Go Embedding, SetInstanceCount for job is hidden
|
||||
req *aurora.JobUpdateRequest
|
||||
}
|
||||
|
||||
func NewUpdateJob(job *Job) *UpdateJob {
|
||||
|
||||
req := aurora.NewJobUpdateRequest()
|
||||
req.TaskConfig = job.jobConfig.TaskConfig
|
||||
req.Settings = aurora.NewJobUpdateSettings()
|
||||
|
||||
// Mirrors defaults set by Pystachio
|
||||
req.Settings.UpdateOnlyTheseInstances = make(map[*aurora.Range]bool)
|
||||
req.Settings.UpdateGroupSize = 1
|
||||
req.Settings.WaitForBatchCompletion = false
|
||||
req.Settings.MinWaitInInstanceRunningMs = 45000 // Deprecated
|
||||
req.Settings.MaxPerInstanceFailures = 0
|
||||
req.Settings.MaxFailedInstances = 0
|
||||
req.Settings.RollbackOnFailure = true
|
||||
req.Settings.WaitForBatchCompletion = false
|
||||
|
||||
//TODO(rdelvalle): Deep copy job
|
||||
return &UpdateJob{job, req}
|
||||
}
|
||||
|
||||
func (u *UpdateJob) SetInstanceCount(inst int32) *UpdateJob {
|
||||
u.req.InstanceCount = inst
|
||||
return u
|
||||
}
|
||||
|
||||
// Max number of instances being updated at any given moment.
|
||||
func (u *UpdateJob) SetBatchSize(size int32) *UpdateJob {
|
||||
u.req.Settings.UpdateGroupSize = size
|
||||
return u
|
||||
}
|
||||
|
||||
// Minimum number of seconds a shard must remain in RUNNING state before considered a success
|
||||
func (u *UpdateJob) SetWatchTime(milliseconds int32) *UpdateJob {
|
||||
u.req.Settings.MaxPerInstanceFailures = milliseconds
|
||||
return u
|
||||
}
|
||||
|
||||
// Wait for all instances in a group to be done before moving on
|
||||
func (u *UpdateJob) SetWaitForBatchCompletion(batchWait bool) *UpdateJob {
|
||||
u.req.Settings.WaitForBatchCompletion = batchWait
|
||||
return u
|
||||
}
|
||||
|
||||
// Max number of instance failures to tolerate before marking instance as FAILED.
|
||||
func (u *UpdateJob) SetMaxPerInstanceFailures(inst int32) *UpdateJob {
|
||||
u.req.Settings.MaxPerInstanceFailures = inst
|
||||
return u
|
||||
}
|
||||
|
||||
// Max number of FAILED instances to tolerate before terminating the update.
|
||||
func (u *UpdateJob) SetMaxFailedInstances(inst int32) *UpdateJob {
|
||||
|
||||
u.req.Settings.MaxFailedInstances = inst
|
||||
return u
|
||||
}
|
||||
|
||||
// When False, prevents auto rollback of a failed update
|
||||
func (u *UpdateJob) SetRollbackOnFail(rollback bool) *UpdateJob {
|
||||
|
||||
u.req.Settings.RollbackOnFailure = rollback
|
||||
return u
|
||||
}
|
||||
20
vendor/errors/errors.go
vendored
Normal file
20
vendor/errors/errors.go
vendored
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package errors implements functions to manipulate errors.
|
||||
package errors
|
||||
|
||||
// New returns an error that formats as the given text.
|
||||
func New(text string) error {
|
||||
return &errorString{text}
|
||||
}
|
||||
|
||||
// errorString is a trivial implementation of error.
|
||||
type errorString struct {
|
||||
s string
|
||||
}
|
||||
|
||||
func (e *errorString) Error() string {
|
||||
return e.s
|
||||
}
|
||||
53
vendor/errors/errors_test.go
vendored
Normal file
53
vendor/errors/errors_test.go
vendored
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package errors_test
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestNewEqual(t *testing.T) {
|
||||
// Different allocations should not be equal.
|
||||
if errors.New("abc") == errors.New("abc") {
|
||||
t.Errorf(`New("abc") == New("abc")`)
|
||||
}
|
||||
if errors.New("abc") == errors.New("xyz") {
|
||||
t.Errorf(`New("abc") == New("xyz")`)
|
||||
}
|
||||
|
||||
// Same allocation should be equal to itself (not crash).
|
||||
err := errors.New("jkl")
|
||||
if err != err {
|
||||
t.Errorf(`err != err`)
|
||||
}
|
||||
}
|
||||
|
||||
func TestErrorMethod(t *testing.T) {
|
||||
err := errors.New("abc")
|
||||
if err.Error() != "abc" {
|
||||
t.Errorf(`New("abc").Error() = %q, want %q`, err.Error(), "abc")
|
||||
}
|
||||
}
|
||||
|
||||
func ExampleNew() {
|
||||
err := errors.New("emit macho dwarf: elf header corrupted")
|
||||
if err != nil {
|
||||
fmt.Print(err)
|
||||
}
|
||||
// Output: emit macho dwarf: elf header corrupted
|
||||
}
|
||||
|
||||
// The fmt package's Errorf function lets us use the package's formatting
|
||||
// features to create descriptive error messages.
|
||||
func ExampleNew_errorf() {
|
||||
const name, id = "bimmler", 17
|
||||
err := fmt.Errorf("user %q (id %d) not found", name, id)
|
||||
if err != nil {
|
||||
fmt.Print(err)
|
||||
}
|
||||
// Output: user "bimmler" (id 17) not found
|
||||
}
|
||||
34
vendor/errors/example_test.go
vendored
Normal file
34
vendor/errors/example_test.go
vendored
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
// Copyright 2012 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package errors_test
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
// MyError is an error implementation that includes a time and message.
|
||||
type MyError struct {
|
||||
When time.Time
|
||||
What string
|
||||
}
|
||||
|
||||
func (e MyError) Error() string {
|
||||
return fmt.Sprintf("%v: %v", e.When, e.What)
|
||||
}
|
||||
|
||||
func oops() error {
|
||||
return MyError{
|
||||
time.Date(1989, 3, 15, 22, 30, 0, 0, time.UTC),
|
||||
"the file system has gone away",
|
||||
}
|
||||
}
|
||||
|
||||
func Example() {
|
||||
if err := oops(); err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
// Output: 1989-03-15 22:30:00 +0000 UTC: the file system has gone away
|
||||
}
|
||||
1055
vendor/gen-go/apache/aurora/aurora_admin-remote/aurora_admin-remote.go
vendored
Executable file
1055
vendor/gen-go/apache/aurora/aurora_admin-remote/aurora_admin-remote.go
vendored
Executable file
File diff suppressed because it is too large
Load diff
771
vendor/gen-go/apache/aurora/aurora_scheduler_manager-remote/aurora_scheduler_manager-remote.go
vendored
Executable file
771
vendor/gen-go/apache/aurora/aurora_scheduler_manager-remote/aurora_scheduler_manager-remote.go
vendored
Executable file
|
|
@ -0,0 +1,771 @@
|
|||
// Autogenerated by Thrift Compiler (0.9.3)
|
||||
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"apache/aurora"
|
||||
"flag"
|
||||
"fmt"
|
||||
"git.apache.org/thrift.git/lib/go/thrift"
|
||||
"math"
|
||||
"net"
|
||||
"net/url"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func Usage() {
|
||||
fmt.Fprintln(os.Stderr, "Usage of ", os.Args[0], " [-h host:port] [-u url] [-f[ramed]] function [arg1 [arg2...]]:")
|
||||
flag.PrintDefaults()
|
||||
fmt.Fprintln(os.Stderr, "\nFunctions:")
|
||||
fmt.Fprintln(os.Stderr, " Response createJob(JobConfiguration description)")
|
||||
fmt.Fprintln(os.Stderr, " Response scheduleCronJob(JobConfiguration description)")
|
||||
fmt.Fprintln(os.Stderr, " Response descheduleCronJob(JobKey job)")
|
||||
fmt.Fprintln(os.Stderr, " Response startCronJob(JobKey job)")
|
||||
fmt.Fprintln(os.Stderr, " Response restartShards(JobKey job, shardIds)")
|
||||
fmt.Fprintln(os.Stderr, " Response killTasks(JobKey job, instances)")
|
||||
fmt.Fprintln(os.Stderr, " Response addInstances(InstanceKey key, i32 count)")
|
||||
fmt.Fprintln(os.Stderr, " Response replaceCronTemplate(JobConfiguration config)")
|
||||
fmt.Fprintln(os.Stderr, " Response startJobUpdate(JobUpdateRequest request, string message)")
|
||||
fmt.Fprintln(os.Stderr, " Response pauseJobUpdate(JobUpdateKey key, string message)")
|
||||
fmt.Fprintln(os.Stderr, " Response resumeJobUpdate(JobUpdateKey key, string message)")
|
||||
fmt.Fprintln(os.Stderr, " Response abortJobUpdate(JobUpdateKey key, string message)")
|
||||
fmt.Fprintln(os.Stderr, " Response pulseJobUpdate(JobUpdateKey key)")
|
||||
fmt.Fprintln(os.Stderr, " Response getRoleSummary()")
|
||||
fmt.Fprintln(os.Stderr, " Response getJobSummary(string role)")
|
||||
fmt.Fprintln(os.Stderr, " Response getTasksStatus(TaskQuery query)")
|
||||
fmt.Fprintln(os.Stderr, " Response getTasksWithoutConfigs(TaskQuery query)")
|
||||
fmt.Fprintln(os.Stderr, " Response getPendingReason(TaskQuery query)")
|
||||
fmt.Fprintln(os.Stderr, " Response getConfigSummary(JobKey job)")
|
||||
fmt.Fprintln(os.Stderr, " Response getJobs(string ownerRole)")
|
||||
fmt.Fprintln(os.Stderr, " Response getQuota(string ownerRole)")
|
||||
fmt.Fprintln(os.Stderr, " Response populateJobConfig(JobConfiguration description)")
|
||||
fmt.Fprintln(os.Stderr, " Response getJobUpdateSummaries(JobUpdateQuery jobUpdateQuery)")
|
||||
fmt.Fprintln(os.Stderr, " Response getJobUpdateDetails(JobUpdateKey key)")
|
||||
fmt.Fprintln(os.Stderr, " Response getJobUpdateDiff(JobUpdateRequest request)")
|
||||
fmt.Fprintln(os.Stderr, " Response getTierConfigs()")
|
||||
fmt.Fprintln(os.Stderr)
|
||||
os.Exit(0)
|
||||
}
|
||||
|
||||
func main() {
|
||||
flag.Usage = Usage
|
||||
var host string
|
||||
var port int
|
||||
var protocol string
|
||||
var urlString string
|
||||
var framed bool
|
||||
var useHttp bool
|
||||
var parsedUrl url.URL
|
||||
var trans thrift.TTransport
|
||||
_ = strconv.Atoi
|
||||
_ = math.Abs
|
||||
flag.Usage = Usage
|
||||
flag.StringVar(&host, "h", "localhost", "Specify host and port")
|
||||
flag.IntVar(&port, "p", 9090, "Specify port")
|
||||
flag.StringVar(&protocol, "P", "binary", "Specify the protocol (binary, compact, simplejson, json)")
|
||||
flag.StringVar(&urlString, "u", "", "Specify the url")
|
||||
flag.BoolVar(&framed, "framed", false, "Use framed transport")
|
||||
flag.BoolVar(&useHttp, "http", false, "Use http")
|
||||
flag.Parse()
|
||||
|
||||
if len(urlString) > 0 {
|
||||
parsedUrl, err := url.Parse(urlString)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "Error parsing URL: ", err)
|
||||
flag.Usage()
|
||||
}
|
||||
host = parsedUrl.Host
|
||||
useHttp = len(parsedUrl.Scheme) <= 0 || parsedUrl.Scheme == "http"
|
||||
} else if useHttp {
|
||||
_, err := url.Parse(fmt.Sprint("http://", host, ":", port))
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "Error parsing URL: ", err)
|
||||
flag.Usage()
|
||||
}
|
||||
}
|
||||
|
||||
cmd := flag.Arg(0)
|
||||
var err error
|
||||
if useHttp {
|
||||
trans, err = thrift.NewTHttpClient(parsedUrl.String())
|
||||
} else {
|
||||
portStr := fmt.Sprint(port)
|
||||
if strings.Contains(host, ":") {
|
||||
host, portStr, err = net.SplitHostPort(host)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "error with host:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
trans, err = thrift.NewTSocket(net.JoinHostPort(host, portStr))
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "error resolving address:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
if framed {
|
||||
trans = thrift.NewTFramedTransport(trans)
|
||||
}
|
||||
}
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "Error creating transport", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
defer trans.Close()
|
||||
var protocolFactory thrift.TProtocolFactory
|
||||
switch protocol {
|
||||
case "compact":
|
||||
protocolFactory = thrift.NewTCompactProtocolFactory()
|
||||
break
|
||||
case "simplejson":
|
||||
protocolFactory = thrift.NewTSimpleJSONProtocolFactory()
|
||||
break
|
||||
case "json":
|
||||
protocolFactory = thrift.NewTJSONProtocolFactory()
|
||||
break
|
||||
case "binary", "":
|
||||
protocolFactory = thrift.NewTBinaryProtocolFactoryDefault()
|
||||
break
|
||||
default:
|
||||
fmt.Fprintln(os.Stderr, "Invalid protocol specified: ", protocol)
|
||||
Usage()
|
||||
os.Exit(1)
|
||||
}
|
||||
client := aurora.NewAuroraSchedulerManagerClientFactory(trans, protocolFactory)
|
||||
if err := trans.Open(); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "Error opening socket to ", host, ":", port, " ", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
switch cmd {
|
||||
case "createJob":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "CreateJob requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg158 := flag.Arg(1)
|
||||
mbTrans159 := thrift.NewTMemoryBufferLen(len(arg158))
|
||||
defer mbTrans159.Close()
|
||||
_, err160 := mbTrans159.WriteString(arg158)
|
||||
if err160 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory161 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt162 := factory161.GetProtocol(mbTrans159)
|
||||
argvalue0 := aurora.NewJobConfiguration()
|
||||
err163 := argvalue0.Read(jsProt162)
|
||||
if err163 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.CreateJob(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "scheduleCronJob":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "ScheduleCronJob requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg164 := flag.Arg(1)
|
||||
mbTrans165 := thrift.NewTMemoryBufferLen(len(arg164))
|
||||
defer mbTrans165.Close()
|
||||
_, err166 := mbTrans165.WriteString(arg164)
|
||||
if err166 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory167 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt168 := factory167.GetProtocol(mbTrans165)
|
||||
argvalue0 := aurora.NewJobConfiguration()
|
||||
err169 := argvalue0.Read(jsProt168)
|
||||
if err169 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.ScheduleCronJob(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "descheduleCronJob":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "DescheduleCronJob requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg170 := flag.Arg(1)
|
||||
mbTrans171 := thrift.NewTMemoryBufferLen(len(arg170))
|
||||
defer mbTrans171.Close()
|
||||
_, err172 := mbTrans171.WriteString(arg170)
|
||||
if err172 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory173 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt174 := factory173.GetProtocol(mbTrans171)
|
||||
argvalue0 := aurora.NewJobKey()
|
||||
err175 := argvalue0.Read(jsProt174)
|
||||
if err175 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.DescheduleCronJob(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "startCronJob":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "StartCronJob requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg176 := flag.Arg(1)
|
||||
mbTrans177 := thrift.NewTMemoryBufferLen(len(arg176))
|
||||
defer mbTrans177.Close()
|
||||
_, err178 := mbTrans177.WriteString(arg176)
|
||||
if err178 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory179 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt180 := factory179.GetProtocol(mbTrans177)
|
||||
argvalue0 := aurora.NewJobKey()
|
||||
err181 := argvalue0.Read(jsProt180)
|
||||
if err181 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.StartCronJob(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "restartShards":
|
||||
if flag.NArg()-1 != 2 {
|
||||
fmt.Fprintln(os.Stderr, "RestartShards requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg182 := flag.Arg(1)
|
||||
mbTrans183 := thrift.NewTMemoryBufferLen(len(arg182))
|
||||
defer mbTrans183.Close()
|
||||
_, err184 := mbTrans183.WriteString(arg182)
|
||||
if err184 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory185 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt186 := factory185.GetProtocol(mbTrans183)
|
||||
argvalue0 := aurora.NewJobKey()
|
||||
err187 := argvalue0.Read(jsProt186)
|
||||
if err187 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
arg188 := flag.Arg(2)
|
||||
mbTrans189 := thrift.NewTMemoryBufferLen(len(arg188))
|
||||
defer mbTrans189.Close()
|
||||
_, err190 := mbTrans189.WriteString(arg188)
|
||||
if err190 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory191 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt192 := factory191.GetProtocol(mbTrans189)
|
||||
containerStruct1 := aurora.NewAuroraSchedulerManagerRestartShardsArgs()
|
||||
err193 := containerStruct1.ReadField2(jsProt192)
|
||||
if err193 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
argvalue1 := containerStruct1.ShardIds
|
||||
value1 := argvalue1
|
||||
fmt.Print(client.RestartShards(value0, value1))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "killTasks":
|
||||
if flag.NArg()-1 != 2 {
|
||||
fmt.Fprintln(os.Stderr, "KillTasks requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg194 := flag.Arg(1)
|
||||
mbTrans195 := thrift.NewTMemoryBufferLen(len(arg194))
|
||||
defer mbTrans195.Close()
|
||||
_, err196 := mbTrans195.WriteString(arg194)
|
||||
if err196 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory197 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt198 := factory197.GetProtocol(mbTrans195)
|
||||
argvalue0 := aurora.NewJobKey()
|
||||
err199 := argvalue0.Read(jsProt198)
|
||||
if err199 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
arg200 := flag.Arg(2)
|
||||
mbTrans201 := thrift.NewTMemoryBufferLen(len(arg200))
|
||||
defer mbTrans201.Close()
|
||||
_, err202 := mbTrans201.WriteString(arg200)
|
||||
if err202 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory203 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt204 := factory203.GetProtocol(mbTrans201)
|
||||
containerStruct1 := aurora.NewAuroraSchedulerManagerKillTasksArgs()
|
||||
err205 := containerStruct1.ReadField2(jsProt204)
|
||||
if err205 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
argvalue1 := containerStruct1.Instances
|
||||
value1 := argvalue1
|
||||
fmt.Print(client.KillTasks(value0, value1))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "addInstances":
|
||||
if flag.NArg()-1 != 2 {
|
||||
fmt.Fprintln(os.Stderr, "AddInstances requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg206 := flag.Arg(1)
|
||||
mbTrans207 := thrift.NewTMemoryBufferLen(len(arg206))
|
||||
defer mbTrans207.Close()
|
||||
_, err208 := mbTrans207.WriteString(arg206)
|
||||
if err208 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory209 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt210 := factory209.GetProtocol(mbTrans207)
|
||||
argvalue0 := aurora.NewInstanceKey()
|
||||
err211 := argvalue0.Read(jsProt210)
|
||||
if err211 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
tmp1, err212 := (strconv.Atoi(flag.Arg(2)))
|
||||
if err212 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
argvalue1 := int32(tmp1)
|
||||
value1 := argvalue1
|
||||
fmt.Print(client.AddInstances(value0, value1))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "replaceCronTemplate":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "ReplaceCronTemplate requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg213 := flag.Arg(1)
|
||||
mbTrans214 := thrift.NewTMemoryBufferLen(len(arg213))
|
||||
defer mbTrans214.Close()
|
||||
_, err215 := mbTrans214.WriteString(arg213)
|
||||
if err215 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory216 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt217 := factory216.GetProtocol(mbTrans214)
|
||||
argvalue0 := aurora.NewJobConfiguration()
|
||||
err218 := argvalue0.Read(jsProt217)
|
||||
if err218 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.ReplaceCronTemplate(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "startJobUpdate":
|
||||
if flag.NArg()-1 != 2 {
|
||||
fmt.Fprintln(os.Stderr, "StartJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg219 := flag.Arg(1)
|
||||
mbTrans220 := thrift.NewTMemoryBufferLen(len(arg219))
|
||||
defer mbTrans220.Close()
|
||||
_, err221 := mbTrans220.WriteString(arg219)
|
||||
if err221 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory222 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt223 := factory222.GetProtocol(mbTrans220)
|
||||
argvalue0 := aurora.NewJobUpdateRequest()
|
||||
err224 := argvalue0.Read(jsProt223)
|
||||
if err224 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
argvalue1 := flag.Arg(2)
|
||||
value1 := argvalue1
|
||||
fmt.Print(client.StartJobUpdate(value0, value1))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "pauseJobUpdate":
|
||||
if flag.NArg()-1 != 2 {
|
||||
fmt.Fprintln(os.Stderr, "PauseJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg226 := flag.Arg(1)
|
||||
mbTrans227 := thrift.NewTMemoryBufferLen(len(arg226))
|
||||
defer mbTrans227.Close()
|
||||
_, err228 := mbTrans227.WriteString(arg226)
|
||||
if err228 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory229 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt230 := factory229.GetProtocol(mbTrans227)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err231 := argvalue0.Read(jsProt230)
|
||||
if err231 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
argvalue1 := flag.Arg(2)
|
||||
value1 := argvalue1
|
||||
fmt.Print(client.PauseJobUpdate(value0, value1))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "resumeJobUpdate":
|
||||
if flag.NArg()-1 != 2 {
|
||||
fmt.Fprintln(os.Stderr, "ResumeJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg233 := flag.Arg(1)
|
||||
mbTrans234 := thrift.NewTMemoryBufferLen(len(arg233))
|
||||
defer mbTrans234.Close()
|
||||
_, err235 := mbTrans234.WriteString(arg233)
|
||||
if err235 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory236 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt237 := factory236.GetProtocol(mbTrans234)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err238 := argvalue0.Read(jsProt237)
|
||||
if err238 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
argvalue1 := flag.Arg(2)
|
||||
value1 := argvalue1
|
||||
fmt.Print(client.ResumeJobUpdate(value0, value1))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "abortJobUpdate":
|
||||
if flag.NArg()-1 != 2 {
|
||||
fmt.Fprintln(os.Stderr, "AbortJobUpdate requires 2 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg240 := flag.Arg(1)
|
||||
mbTrans241 := thrift.NewTMemoryBufferLen(len(arg240))
|
||||
defer mbTrans241.Close()
|
||||
_, err242 := mbTrans241.WriteString(arg240)
|
||||
if err242 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory243 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt244 := factory243.GetProtocol(mbTrans241)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err245 := argvalue0.Read(jsProt244)
|
||||
if err245 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
argvalue1 := flag.Arg(2)
|
||||
value1 := argvalue1
|
||||
fmt.Print(client.AbortJobUpdate(value0, value1))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "pulseJobUpdate":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "PulseJobUpdate requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg247 := flag.Arg(1)
|
||||
mbTrans248 := thrift.NewTMemoryBufferLen(len(arg247))
|
||||
defer mbTrans248.Close()
|
||||
_, err249 := mbTrans248.WriteString(arg247)
|
||||
if err249 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory250 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt251 := factory250.GetProtocol(mbTrans248)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err252 := argvalue0.Read(jsProt251)
|
||||
if err252 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.PulseJobUpdate(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getRoleSummary":
|
||||
if flag.NArg()-1 != 0 {
|
||||
fmt.Fprintln(os.Stderr, "GetRoleSummary requires 0 args")
|
||||
flag.Usage()
|
||||
}
|
||||
fmt.Print(client.GetRoleSummary())
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getJobSummary":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetJobSummary requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
argvalue0 := flag.Arg(1)
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetJobSummary(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getTasksStatus":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg254 := flag.Arg(1)
|
||||
mbTrans255 := thrift.NewTMemoryBufferLen(len(arg254))
|
||||
defer mbTrans255.Close()
|
||||
_, err256 := mbTrans255.WriteString(arg254)
|
||||
if err256 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory257 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt258 := factory257.GetProtocol(mbTrans255)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err259 := argvalue0.Read(jsProt258)
|
||||
if err259 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetTasksStatus(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getTasksWithoutConfigs":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg260 := flag.Arg(1)
|
||||
mbTrans261 := thrift.NewTMemoryBufferLen(len(arg260))
|
||||
defer mbTrans261.Close()
|
||||
_, err262 := mbTrans261.WriteString(arg260)
|
||||
if err262 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory263 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt264 := factory263.GetProtocol(mbTrans261)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err265 := argvalue0.Read(jsProt264)
|
||||
if err265 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetTasksWithoutConfigs(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getPendingReason":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg266 := flag.Arg(1)
|
||||
mbTrans267 := thrift.NewTMemoryBufferLen(len(arg266))
|
||||
defer mbTrans267.Close()
|
||||
_, err268 := mbTrans267.WriteString(arg266)
|
||||
if err268 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory269 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt270 := factory269.GetProtocol(mbTrans267)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err271 := argvalue0.Read(jsProt270)
|
||||
if err271 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetPendingReason(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getConfigSummary":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg272 := flag.Arg(1)
|
||||
mbTrans273 := thrift.NewTMemoryBufferLen(len(arg272))
|
||||
defer mbTrans273.Close()
|
||||
_, err274 := mbTrans273.WriteString(arg272)
|
||||
if err274 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory275 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt276 := factory275.GetProtocol(mbTrans273)
|
||||
argvalue0 := aurora.NewJobKey()
|
||||
err277 := argvalue0.Read(jsProt276)
|
||||
if err277 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetConfigSummary(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getJobs":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetJobs requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
argvalue0 := flag.Arg(1)
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetJobs(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getQuota":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetQuota requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
argvalue0 := flag.Arg(1)
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetQuota(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "populateJobConfig":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg280 := flag.Arg(1)
|
||||
mbTrans281 := thrift.NewTMemoryBufferLen(len(arg280))
|
||||
defer mbTrans281.Close()
|
||||
_, err282 := mbTrans281.WriteString(arg280)
|
||||
if err282 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory283 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt284 := factory283.GetProtocol(mbTrans281)
|
||||
argvalue0 := aurora.NewJobConfiguration()
|
||||
err285 := argvalue0.Read(jsProt284)
|
||||
if err285 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.PopulateJobConfig(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getJobUpdateSummaries":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg286 := flag.Arg(1)
|
||||
mbTrans287 := thrift.NewTMemoryBufferLen(len(arg286))
|
||||
defer mbTrans287.Close()
|
||||
_, err288 := mbTrans287.WriteString(arg286)
|
||||
if err288 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory289 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt290 := factory289.GetProtocol(mbTrans287)
|
||||
argvalue0 := aurora.NewJobUpdateQuery()
|
||||
err291 := argvalue0.Read(jsProt290)
|
||||
if err291 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetJobUpdateSummaries(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getJobUpdateDetails":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg292 := flag.Arg(1)
|
||||
mbTrans293 := thrift.NewTMemoryBufferLen(len(arg292))
|
||||
defer mbTrans293.Close()
|
||||
_, err294 := mbTrans293.WriteString(arg292)
|
||||
if err294 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory295 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt296 := factory295.GetProtocol(mbTrans293)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err297 := argvalue0.Read(jsProt296)
|
||||
if err297 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetJobUpdateDetails(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getJobUpdateDiff":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg298 := flag.Arg(1)
|
||||
mbTrans299 := thrift.NewTMemoryBufferLen(len(arg298))
|
||||
defer mbTrans299.Close()
|
||||
_, err300 := mbTrans299.WriteString(arg298)
|
||||
if err300 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory301 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt302 := factory301.GetProtocol(mbTrans299)
|
||||
argvalue0 := aurora.NewJobUpdateRequest()
|
||||
err303 := argvalue0.Read(jsProt302)
|
||||
if err303 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetJobUpdateDiff(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getTierConfigs":
|
||||
if flag.NArg()-1 != 0 {
|
||||
fmt.Fprintln(os.Stderr, "GetTierConfigs requires 0 args")
|
||||
flag.Usage()
|
||||
}
|
||||
fmt.Print(client.GetTierConfigs())
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "":
|
||||
Usage()
|
||||
break
|
||||
default:
|
||||
fmt.Fprintln(os.Stderr, "Invalid function ", cmd)
|
||||
}
|
||||
}
|
||||
4841
vendor/gen-go/apache/aurora/auroraadmin.go
vendored
Normal file
4841
vendor/gen-go/apache/aurora/auroraadmin.go
vendored
Normal file
File diff suppressed because it is too large
Load diff
4706
vendor/gen-go/apache/aurora/auroraschedulermanager.go
vendored
Normal file
4706
vendor/gen-go/apache/aurora/auroraschedulermanager.go
vendored
Normal file
File diff suppressed because it is too large
Load diff
79
vendor/gen-go/apache/aurora/constants.go
vendored
Normal file
79
vendor/gen-go/apache/aurora/constants.go
vendored
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
// Autogenerated by Thrift Compiler (0.9.3)
|
||||
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
|
||||
|
||||
package aurora
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"git.apache.org/thrift.git/lib/go/thrift"
|
||||
)
|
||||
|
||||
// (needed to ensure safety because of naive import list construction.)
|
||||
var _ = thrift.ZERO
|
||||
var _ = fmt.Printf
|
||||
var _ = bytes.Equal
|
||||
|
||||
const AURORA_EXECUTOR_NAME = "AuroraExecutor"
|
||||
|
||||
var ACTIVE_STATES map[ScheduleStatus]bool
|
||||
var SLAVE_ASSIGNED_STATES map[ScheduleStatus]bool
|
||||
var LIVE_STATES map[ScheduleStatus]bool
|
||||
var TERMINAL_STATES map[ScheduleStatus]bool
|
||||
|
||||
const GOOD_IDENTIFIER_PATTERN = "^[\\w\\-\\.]+$"
|
||||
const GOOD_IDENTIFIER_PATTERN_JVM = "^[\\w\\-\\.]+$"
|
||||
const GOOD_IDENTIFIER_PATTERN_PYTHON = "^[\\w\\-\\.]+$"
|
||||
|
||||
var ACTIVE_JOB_UPDATE_STATES map[JobUpdateStatus]bool
|
||||
|
||||
const BYPASS_LEADER_REDIRECT_HEADER_NAME = "Bypass-Leader-Redirect"
|
||||
|
||||
func init() {
|
||||
ACTIVE_STATES = map[ScheduleStatus]bool{
|
||||
9: true,
|
||||
17: true,
|
||||
6: true,
|
||||
0: true,
|
||||
13: true,
|
||||
12: true,
|
||||
2: true,
|
||||
1: true,
|
||||
16: true,
|
||||
}
|
||||
|
||||
SLAVE_ASSIGNED_STATES = map[ScheduleStatus]bool{
|
||||
9: true,
|
||||
17: true,
|
||||
6: true,
|
||||
13: true,
|
||||
12: true,
|
||||
2: true,
|
||||
1: true,
|
||||
}
|
||||
|
||||
LIVE_STATES = map[ScheduleStatus]bool{
|
||||
6: true,
|
||||
13: true,
|
||||
12: true,
|
||||
17: true,
|
||||
2: true,
|
||||
}
|
||||
|
||||
TERMINAL_STATES = map[ScheduleStatus]bool{
|
||||
4: true,
|
||||
3: true,
|
||||
5: true,
|
||||
7: true,
|
||||
}
|
||||
|
||||
ACTIVE_JOB_UPDATE_STATES = map[JobUpdateStatus]bool{
|
||||
0: true,
|
||||
1: true,
|
||||
2: true,
|
||||
3: true,
|
||||
9: true,
|
||||
10: true,
|
||||
}
|
||||
|
||||
}
|
||||
382
vendor/gen-go/apache/aurora/read_only_scheduler-remote/read_only_scheduler-remote.go
vendored
Executable file
382
vendor/gen-go/apache/aurora/read_only_scheduler-remote/read_only_scheduler-remote.go
vendored
Executable file
|
|
@ -0,0 +1,382 @@
|
|||
// Autogenerated by Thrift Compiler (0.9.3)
|
||||
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"apache/aurora"
|
||||
"flag"
|
||||
"fmt"
|
||||
"git.apache.org/thrift.git/lib/go/thrift"
|
||||
"math"
|
||||
"net"
|
||||
"net/url"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func Usage() {
|
||||
fmt.Fprintln(os.Stderr, "Usage of ", os.Args[0], " [-h host:port] [-u url] [-f[ramed]] function [arg1 [arg2...]]:")
|
||||
flag.PrintDefaults()
|
||||
fmt.Fprintln(os.Stderr, "\nFunctions:")
|
||||
fmt.Fprintln(os.Stderr, " Response getRoleSummary()")
|
||||
fmt.Fprintln(os.Stderr, " Response getJobSummary(string role)")
|
||||
fmt.Fprintln(os.Stderr, " Response getTasksStatus(TaskQuery query)")
|
||||
fmt.Fprintln(os.Stderr, " Response getTasksWithoutConfigs(TaskQuery query)")
|
||||
fmt.Fprintln(os.Stderr, " Response getPendingReason(TaskQuery query)")
|
||||
fmt.Fprintln(os.Stderr, " Response getConfigSummary(JobKey job)")
|
||||
fmt.Fprintln(os.Stderr, " Response getJobs(string ownerRole)")
|
||||
fmt.Fprintln(os.Stderr, " Response getQuota(string ownerRole)")
|
||||
fmt.Fprintln(os.Stderr, " Response populateJobConfig(JobConfiguration description)")
|
||||
fmt.Fprintln(os.Stderr, " Response getJobUpdateSummaries(JobUpdateQuery jobUpdateQuery)")
|
||||
fmt.Fprintln(os.Stderr, " Response getJobUpdateDetails(JobUpdateKey key)")
|
||||
fmt.Fprintln(os.Stderr, " Response getJobUpdateDiff(JobUpdateRequest request)")
|
||||
fmt.Fprintln(os.Stderr, " Response getTierConfigs()")
|
||||
fmt.Fprintln(os.Stderr)
|
||||
os.Exit(0)
|
||||
}
|
||||
|
||||
func main() {
|
||||
flag.Usage = Usage
|
||||
var host string
|
||||
var port int
|
||||
var protocol string
|
||||
var urlString string
|
||||
var framed bool
|
||||
var useHttp bool
|
||||
var parsedUrl url.URL
|
||||
var trans thrift.TTransport
|
||||
_ = strconv.Atoi
|
||||
_ = math.Abs
|
||||
flag.Usage = Usage
|
||||
flag.StringVar(&host, "h", "localhost", "Specify host and port")
|
||||
flag.IntVar(&port, "p", 9090, "Specify port")
|
||||
flag.StringVar(&protocol, "P", "binary", "Specify the protocol (binary, compact, simplejson, json)")
|
||||
flag.StringVar(&urlString, "u", "", "Specify the url")
|
||||
flag.BoolVar(&framed, "framed", false, "Use framed transport")
|
||||
flag.BoolVar(&useHttp, "http", false, "Use http")
|
||||
flag.Parse()
|
||||
|
||||
if len(urlString) > 0 {
|
||||
parsedUrl, err := url.Parse(urlString)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "Error parsing URL: ", err)
|
||||
flag.Usage()
|
||||
}
|
||||
host = parsedUrl.Host
|
||||
useHttp = len(parsedUrl.Scheme) <= 0 || parsedUrl.Scheme == "http"
|
||||
} else if useHttp {
|
||||
_, err := url.Parse(fmt.Sprint("http://", host, ":", port))
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "Error parsing URL: ", err)
|
||||
flag.Usage()
|
||||
}
|
||||
}
|
||||
|
||||
cmd := flag.Arg(0)
|
||||
var err error
|
||||
if useHttp {
|
||||
trans, err = thrift.NewTHttpClient(parsedUrl.String())
|
||||
} else {
|
||||
portStr := fmt.Sprint(port)
|
||||
if strings.Contains(host, ":") {
|
||||
host, portStr, err = net.SplitHostPort(host)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "error with host:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
trans, err = thrift.NewTSocket(net.JoinHostPort(host, portStr))
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "error resolving address:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
if framed {
|
||||
trans = thrift.NewTFramedTransport(trans)
|
||||
}
|
||||
}
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "Error creating transport", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
defer trans.Close()
|
||||
var protocolFactory thrift.TProtocolFactory
|
||||
switch protocol {
|
||||
case "compact":
|
||||
protocolFactory = thrift.NewTCompactProtocolFactory()
|
||||
break
|
||||
case "simplejson":
|
||||
protocolFactory = thrift.NewTSimpleJSONProtocolFactory()
|
||||
break
|
||||
case "json":
|
||||
protocolFactory = thrift.NewTJSONProtocolFactory()
|
||||
break
|
||||
case "binary", "":
|
||||
protocolFactory = thrift.NewTBinaryProtocolFactoryDefault()
|
||||
break
|
||||
default:
|
||||
fmt.Fprintln(os.Stderr, "Invalid protocol specified: ", protocol)
|
||||
Usage()
|
||||
os.Exit(1)
|
||||
}
|
||||
client := aurora.NewReadOnlySchedulerClientFactory(trans, protocolFactory)
|
||||
if err := trans.Open(); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "Error opening socket to ", host, ":", port, " ", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
switch cmd {
|
||||
case "getRoleSummary":
|
||||
if flag.NArg()-1 != 0 {
|
||||
fmt.Fprintln(os.Stderr, "GetRoleSummary requires 0 args")
|
||||
flag.Usage()
|
||||
}
|
||||
fmt.Print(client.GetRoleSummary())
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getJobSummary":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetJobSummary requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
argvalue0 := flag.Arg(1)
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetJobSummary(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getTasksStatus":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetTasksStatus requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg79 := flag.Arg(1)
|
||||
mbTrans80 := thrift.NewTMemoryBufferLen(len(arg79))
|
||||
defer mbTrans80.Close()
|
||||
_, err81 := mbTrans80.WriteString(arg79)
|
||||
if err81 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory82 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt83 := factory82.GetProtocol(mbTrans80)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err84 := argvalue0.Read(jsProt83)
|
||||
if err84 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetTasksStatus(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getTasksWithoutConfigs":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetTasksWithoutConfigs requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg85 := flag.Arg(1)
|
||||
mbTrans86 := thrift.NewTMemoryBufferLen(len(arg85))
|
||||
defer mbTrans86.Close()
|
||||
_, err87 := mbTrans86.WriteString(arg85)
|
||||
if err87 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory88 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt89 := factory88.GetProtocol(mbTrans86)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err90 := argvalue0.Read(jsProt89)
|
||||
if err90 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetTasksWithoutConfigs(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getPendingReason":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetPendingReason requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg91 := flag.Arg(1)
|
||||
mbTrans92 := thrift.NewTMemoryBufferLen(len(arg91))
|
||||
defer mbTrans92.Close()
|
||||
_, err93 := mbTrans92.WriteString(arg91)
|
||||
if err93 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory94 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt95 := factory94.GetProtocol(mbTrans92)
|
||||
argvalue0 := aurora.NewTaskQuery()
|
||||
err96 := argvalue0.Read(jsProt95)
|
||||
if err96 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetPendingReason(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getConfigSummary":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetConfigSummary requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg97 := flag.Arg(1)
|
||||
mbTrans98 := thrift.NewTMemoryBufferLen(len(arg97))
|
||||
defer mbTrans98.Close()
|
||||
_, err99 := mbTrans98.WriteString(arg97)
|
||||
if err99 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory100 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt101 := factory100.GetProtocol(mbTrans98)
|
||||
argvalue0 := aurora.NewJobKey()
|
||||
err102 := argvalue0.Read(jsProt101)
|
||||
if err102 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetConfigSummary(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getJobs":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetJobs requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
argvalue0 := flag.Arg(1)
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetJobs(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getQuota":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetQuota requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
argvalue0 := flag.Arg(1)
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetQuota(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "populateJobConfig":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "PopulateJobConfig requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg105 := flag.Arg(1)
|
||||
mbTrans106 := thrift.NewTMemoryBufferLen(len(arg105))
|
||||
defer mbTrans106.Close()
|
||||
_, err107 := mbTrans106.WriteString(arg105)
|
||||
if err107 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory108 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt109 := factory108.GetProtocol(mbTrans106)
|
||||
argvalue0 := aurora.NewJobConfiguration()
|
||||
err110 := argvalue0.Read(jsProt109)
|
||||
if err110 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.PopulateJobConfig(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getJobUpdateSummaries":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetJobUpdateSummaries requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg111 := flag.Arg(1)
|
||||
mbTrans112 := thrift.NewTMemoryBufferLen(len(arg111))
|
||||
defer mbTrans112.Close()
|
||||
_, err113 := mbTrans112.WriteString(arg111)
|
||||
if err113 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory114 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt115 := factory114.GetProtocol(mbTrans112)
|
||||
argvalue0 := aurora.NewJobUpdateQuery()
|
||||
err116 := argvalue0.Read(jsProt115)
|
||||
if err116 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetJobUpdateSummaries(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getJobUpdateDetails":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetJobUpdateDetails requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg117 := flag.Arg(1)
|
||||
mbTrans118 := thrift.NewTMemoryBufferLen(len(arg117))
|
||||
defer mbTrans118.Close()
|
||||
_, err119 := mbTrans118.WriteString(arg117)
|
||||
if err119 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory120 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt121 := factory120.GetProtocol(mbTrans118)
|
||||
argvalue0 := aurora.NewJobUpdateKey()
|
||||
err122 := argvalue0.Read(jsProt121)
|
||||
if err122 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetJobUpdateDetails(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getJobUpdateDiff":
|
||||
if flag.NArg()-1 != 1 {
|
||||
fmt.Fprintln(os.Stderr, "GetJobUpdateDiff requires 1 args")
|
||||
flag.Usage()
|
||||
}
|
||||
arg123 := flag.Arg(1)
|
||||
mbTrans124 := thrift.NewTMemoryBufferLen(len(arg123))
|
||||
defer mbTrans124.Close()
|
||||
_, err125 := mbTrans124.WriteString(arg123)
|
||||
if err125 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
factory126 := thrift.NewTSimpleJSONProtocolFactory()
|
||||
jsProt127 := factory126.GetProtocol(mbTrans124)
|
||||
argvalue0 := aurora.NewJobUpdateRequest()
|
||||
err128 := argvalue0.Read(jsProt127)
|
||||
if err128 != nil {
|
||||
Usage()
|
||||
return
|
||||
}
|
||||
value0 := argvalue0
|
||||
fmt.Print(client.GetJobUpdateDiff(value0))
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "getTierConfigs":
|
||||
if flag.NArg()-1 != 0 {
|
||||
fmt.Fprintln(os.Stderr, "GetTierConfigs requires 0 args")
|
||||
flag.Usage()
|
||||
}
|
||||
fmt.Print(client.GetTierConfigs())
|
||||
fmt.Print("\n")
|
||||
break
|
||||
case "":
|
||||
Usage()
|
||||
break
|
||||
default:
|
||||
fmt.Fprintln(os.Stderr, "Invalid function ", cmd)
|
||||
}
|
||||
}
|
||||
4292
vendor/gen-go/apache/aurora/readonlyscheduler.go
vendored
Normal file
4292
vendor/gen-go/apache/aurora/readonlyscheduler.go
vendored
Normal file
File diff suppressed because it is too large
Load diff
15610
vendor/gen-go/apache/aurora/ttypes.go
vendored
Normal file
15610
vendor/gen-go/apache/aurora/ttypes.go
vendored
Normal file
File diff suppressed because it is too large
Load diff
239
vendor/git.apache.org/thrift.git/LICENSE
generated
vendored
Normal file
239
vendor/git.apache.org/thrift.git/LICENSE
generated
vendored
Normal file
|
|
@ -0,0 +1,239 @@
|
|||
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright [yyyy] [name of copyright owner]
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
|
||||
--------------------------------------------------
|
||||
SOFTWARE DISTRIBUTED WITH THRIFT:
|
||||
|
||||
The Apache Thrift software includes a number of subcomponents with
|
||||
separate copyright notices and license terms. Your use of the source
|
||||
code for the these subcomponents is subject to the terms and
|
||||
conditions of the following licenses.
|
||||
|
||||
--------------------------------------------------
|
||||
Portions of the following files are licensed under the MIT License:
|
||||
|
||||
lib/erl/src/Makefile.am
|
||||
|
||||
Please see doc/otp-base-license.txt for the full terms of this license.
|
||||
|
||||
--------------------------------------------------
|
||||
For the aclocal/ax_boost_base.m4 and contrib/fb303/aclocal/ax_boost_base.m4 components:
|
||||
|
||||
# Copyright (c) 2007 Thomas Porschberg <thomas@randspringer.de>
|
||||
#
|
||||
# Copying and distribution of this file, with or without
|
||||
# modification, are permitted in any medium without royalty provided
|
||||
# the copyright notice and this notice are preserved.
|
||||
|
||||
--------------------------------------------------
|
||||
For the lib/nodejs/lib/thrift/json_parse.js:
|
||||
|
||||
/*
|
||||
json_parse.js
|
||||
2015-05-02
|
||||
Public Domain.
|
||||
NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
|
||||
|
||||
*/
|
||||
(By Douglas Crockford <douglas@crockford.com>)
|
||||
--------------------------------------------------
|
||||
5
vendor/git.apache.org/thrift.git/NOTICE
generated
vendored
Normal file
5
vendor/git.apache.org/thrift.git/NOTICE
generated
vendored
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
Apache Thrift
|
||||
Copyright 2006-2010 The Apache Software Foundation.
|
||||
|
||||
This product includes software developed at
|
||||
The Apache Software Foundation (http://www.apache.org/).
|
||||
142
vendor/git.apache.org/thrift.git/lib/go/thrift/application_exception.go
generated
vendored
Normal file
142
vendor/git.apache.org/thrift.git/lib/go/thrift/application_exception.go
generated
vendored
Normal file
|
|
@ -0,0 +1,142 @@
|
|||
/*
|
||||
* 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
|
||||
)
|
||||
|
||||
// Application level Thrift exception
|
||||
type TApplicationException interface {
|
||||
TException
|
||||
TypeId() int32
|
||||
Read(iprot TProtocol) (TApplicationException, error)
|
||||
Write(oprot TProtocol) error
|
||||
}
|
||||
|
||||
type tApplicationException struct {
|
||||
message string
|
||||
type_ int32
|
||||
}
|
||||
|
||||
func (e tApplicationException) Error() string {
|
||||
return e.message
|
||||
}
|
||||
|
||||
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) (TApplicationException, error) {
|
||||
_, err := iprot.ReadStructBegin()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
message := ""
|
||||
type_ := int32(UNKNOWN_APPLICATION_EXCEPTION)
|
||||
|
||||
for {
|
||||
_, ttype, id, err := iprot.ReadFieldBegin()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if ttype == STOP {
|
||||
break
|
||||
}
|
||||
switch id {
|
||||
case 1:
|
||||
if ttype == STRING {
|
||||
if message, err = iprot.ReadString(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
} else {
|
||||
if err = SkipDefaultDepth(iprot, ttype); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
case 2:
|
||||
if ttype == I32 {
|
||||
if type_, err = iprot.ReadI32(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
} else {
|
||||
if err = SkipDefaultDepth(iprot, ttype); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
default:
|
||||
if err = SkipDefaultDepth(iprot, ttype); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
if err = iprot.ReadFieldEnd(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return NewTApplicationException(type_, message), iprot.ReadStructEnd()
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
41
vendor/git.apache.org/thrift.git/lib/go/thrift/application_exception_test.go
generated
vendored
Normal file
41
vendor/git.apache.org/thrift.git/lib/go/thrift/application_exception_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
/*
|
||||
* 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() != "" {
|
||||
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 '%s'", 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 '%s'", exc.TypeId())
|
||||
}
|
||||
}
|
||||
514
vendor/git.apache.org/thrift.git/lib/go/thrift/binary_protocol.go
generated
vendored
Normal file
514
vendor/git.apache.org/thrift.git/lib/go/thrift/binary_protocol.go
generated
vendored
Normal file
|
|
@ -0,0 +1,514 @@
|
|||
/*
|
||||
* 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"
|
||||
"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
|
||||
}
|
||||
if uint64(size) > p.trans.RemainingBytes() {
|
||||
return nil, invalidDataLength
|
||||
}
|
||||
|
||||
isize := int(size)
|
||||
buf := make([]byte, isize)
|
||||
_, err := io.ReadFull(p.trans, buf)
|
||||
return buf, NewTProtocolException(err)
|
||||
}
|
||||
|
||||
func (p *TBinaryProtocol) Flush() (err error) {
|
||||
return NewTProtocolException(p.trans.Flush())
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
if uint64(size) > p.trans.RemainingBytes() {
|
||||
return "", invalidDataLength
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
28
vendor/git.apache.org/thrift.git/lib/go/thrift/binary_protocol_test.go
generated
vendored
Normal file
28
vendor/git.apache.org/thrift.git/lib/go/thrift/binary_protocol_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
/*
|
||||
* 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())
|
||||
}
|
||||
91
vendor/git.apache.org/thrift.git/lib/go/thrift/buffered_transport.go
generated
vendored
Normal file
91
vendor/git.apache.org/thrift.git/lib/go/thrift/buffered_transport.go
generated
vendored
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
/*
|
||||
* 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"
|
||||
)
|
||||
|
||||
type TBufferedTransportFactory struct {
|
||||
size int
|
||||
}
|
||||
|
||||
type TBufferedTransport struct {
|
||||
bufio.ReadWriter
|
||||
tp TTransport
|
||||
}
|
||||
|
||||
func (p *TBufferedTransportFactory) GetTransport(trans TTransport) TTransport {
|
||||
return NewTBufferedTransport(trans, p.size)
|
||||
}
|
||||
|
||||
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() error {
|
||||
if err := p.ReadWriter.Flush(); err != nil {
|
||||
p.ReadWriter.Writer.Reset(p.tp)
|
||||
return err
|
||||
}
|
||||
return p.tp.Flush()
|
||||
}
|
||||
|
||||
func (p *TBufferedTransport) RemainingBytes() (num_bytes uint64) {
|
||||
return p.tp.RemainingBytes()
|
||||
}
|
||||
29
vendor/git.apache.org/thrift.git/lib/go/thrift/buffered_transport_test.go
generated
vendored
Normal file
29
vendor/git.apache.org/thrift.git/lib/go/thrift/buffered_transport_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
/*
|
||||
* 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)
|
||||
}
|
||||
815
vendor/git.apache.org/thrift.git/lib/go/thrift/compact_protocol.go
generated
vendored
Normal file
815
vendor/git.apache.org/thrift.git/lib/go/thrift/compact_protocol.go
generated
vendored
Normal file
|
|
@ -0,0 +1,815 @@
|
|||
/*
|
||||
* 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/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 uint64(length) > p.trans.RemainingBytes() {
|
||||
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
|
||||
}
|
||||
if uint64(length) > p.trans.RemainingBytes() {
|
||||
return nil, invalidDataLength
|
||||
}
|
||||
|
||||
buf := make([]byte, length)
|
||||
_, e = io.ReadFull(p.trans, buf)
|
||||
return buf, NewTProtocolException(e)
|
||||
}
|
||||
|
||||
func (p *TCompactProtocol) Flush() (err error) {
|
||||
return NewTProtocolException(p.trans.Flush())
|
||||
}
|
||||
|
||||
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: %s", t&0x0f))
|
||||
}
|
||||
|
||||
// Given a TType value, find the appropriate TCompactProtocol.Types constant.
|
||||
func (p *TCompactProtocol) getCompactType(t TType) tCompactType {
|
||||
return ttypeToCompactType[t]
|
||||
}
|
||||
53
vendor/git.apache.org/thrift.git/lib/go/thrift/compact_protocol_test.go
generated
vendored
Normal file
53
vendor/git.apache.org/thrift.git/lib/go/thrift/compact_protocol_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
/*
|
||||
* 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()),
|
||||
}
|
||||
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();
|
||||
}
|
||||
}
|
||||
269
vendor/git.apache.org/thrift.git/lib/go/thrift/debug_protocol.go
generated
vendored
Normal file
269
vendor/git.apache.org/thrift.git/lib/go/thrift/debug_protocol.go
generated
vendored
Normal file
|
|
@ -0,0 +1,269 @@
|
|||
/*
|
||||
* 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"
|
||||
)
|
||||
|
||||
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() (err error) {
|
||||
err = tdp.Delegate.Flush()
|
||||
log.Printf("%sFlush() (err=%#v)", tdp.LogPrefix, err)
|
||||
return
|
||||
}
|
||||
|
||||
func (tdp *TDebugProtocol) Transport() TTransport {
|
||||
return tdp.Delegate.Transport()
|
||||
}
|
||||
58
vendor/git.apache.org/thrift.git/lib/go/thrift/deserializer.go
generated
vendored
Normal file
58
vendor/git.apache.org/thrift.git/lib/go/thrift/deserializer.go
generated
vendored
Normal file
|
|
@ -0,0 +1,58 @@
|
|||
/*
|
||||
* 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
|
||||
}
|
||||
44
vendor/git.apache.org/thrift.git/lib/go/thrift/exception.go
generated
vendored
Normal file
44
vendor/git.apache.org/thrift.git/lib/go/thrift/exception.go
generated
vendored
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
/*
|
||||
* 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())
|
||||
}
|
||||
69
vendor/git.apache.org/thrift.git/lib/go/thrift/exception_test.go
generated
vendored
Normal file
69
vendor/git.apache.org/thrift.git/lib/go/thrift/exception_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,69 @@
|
|||
/*
|
||||
* 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")
|
||||
}
|
||||
}
|
||||
79
vendor/git.apache.org/thrift.git/lib/go/thrift/field.go
generated
vendored
Normal file
79
vendor/git.apache.org/thrift.git/lib/go/thrift/field.go
generated
vendored
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
/*
|
||||
* 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)
|
||||
}
|
||||
167
vendor/git.apache.org/thrift.git/lib/go/thrift/framed_transport.go
generated
vendored
Normal file
167
vendor/git.apache.org/thrift.git/lib/go/thrift/framed_transport.go
generated
vendored
Normal file
|
|
@ -0,0 +1,167 @@
|
|||
/*
|
||||
* 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"
|
||||
"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 {
|
||||
return NewTFramedTransportMaxLength(p.factory.GetTransport(base), p.maxLength)
|
||||
}
|
||||
|
||||
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() error {
|
||||
size := p.buf.Len()
|
||||
buf := p.buffer[:4]
|
||||
binary.BigEndian.PutUint32(buf, uint32(size))
|
||||
_, err := p.transport.Write(buf)
|
||||
if err != nil {
|
||||
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")
|
||||
return NewTTransportExceptionFromError(err)
|
||||
}
|
||||
}
|
||||
err = p.transport.Flush()
|
||||
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)
|
||||
}
|
||||
|
||||
29
vendor/git.apache.org/thrift.git/lib/go/thrift/framed_transport_test.go
generated
vendored
Normal file
29
vendor/git.apache.org/thrift.git/lib/go/thrift/framed_transport_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
/*
|
||||
* 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)
|
||||
}
|
||||
258
vendor/git.apache.org/thrift.git/lib/go/thrift/http_client.go
generated
vendored
Normal file
258
vendor/git.apache.org/thrift.git/lib/go/thrift/http_client.go
generated
vendored
Normal file
|
|
@ -0,0 +1,258 @@
|
|||
/*
|
||||
* 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"
|
||||
"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
|
||||
isPost bool
|
||||
}
|
||||
|
||||
func (p *THttpClientTransportFactory) GetTransport(trans TTransport) TTransport {
|
||||
if trans != nil {
|
||||
t, ok := trans.(*THttpClient)
|
||||
if ok && t.url != nil {
|
||||
if t.requestBuffer != nil {
|
||||
t2, _ := NewTHttpPostClientWithOptions(t.url.String(), p.options)
|
||||
return t2
|
||||
}
|
||||
t2, _ := NewTHttpClientWithOptions(t.url.String(), p.options)
|
||||
return t2
|
||||
}
|
||||
}
|
||||
if p.isPost {
|
||||
s, _ := NewTHttpPostClientWithOptions(p.url, p.options)
|
||||
return s
|
||||
}
|
||||
s, _ := NewTHttpClientWithOptions(p.url, p.options)
|
||||
return s
|
||||
}
|
||||
|
||||
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, isPost: false, options: options}
|
||||
}
|
||||
|
||||
func NewTHttpPostClientTransportFactory(url string) *THttpClientTransportFactory {
|
||||
return NewTHttpPostClientTransportFactoryWithOptions(url, THttpClientOptions{})
|
||||
}
|
||||
|
||||
func NewTHttpPostClientTransportFactoryWithOptions(url string, options THttpClientOptions) *THttpClientTransportFactory {
|
||||
return &THttpClientTransportFactory{url: url, isPost: true, options: options}
|
||||
}
|
||||
|
||||
func NewTHttpClientWithOptions(urlstr string, options THttpClientOptions) (TTransport, error) {
|
||||
parsedURL, err := url.Parse(urlstr)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
response, err := http.Get(urlstr)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
client := options.Client
|
||||
if client == nil {
|
||||
client = DefaultHttpClient
|
||||
}
|
||||
httpHeader := map[string][]string{"Content-Type": []string{"application/x-thrift"}}
|
||||
return &THttpClient{client: client, response: response, url: parsedURL, header: httpHeader}, nil
|
||||
}
|
||||
|
||||
func NewTHttpClient(urlstr string) (TTransport, error) {
|
||||
return NewTHttpClientWithOptions(urlstr, THttpClientOptions{})
|
||||
}
|
||||
|
||||
func NewTHttpPostClientWithOptions(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": []string{"application/x-thrift"}}
|
||||
return &THttpClient{client: client, url: parsedURL, requestBuffer: bytes.NewBuffer(buf), header: httpHeader}, nil
|
||||
}
|
||||
|
||||
func NewTHttpPostClient(urlstr string) (TTransport, error) {
|
||||
return NewTHttpPostClientWithOptions(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() 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
|
||||
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
|
||||
}
|
||||
106
vendor/git.apache.org/thrift.git/lib/go/thrift/http_client_test.go
generated
vendored
Normal file
106
vendor/git.apache.org/thrift.git/lib/go/thrift/http_client_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,106 @@
|
|||
/*
|
||||
* 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)
|
||||
}
|
||||
34
vendor/git.apache.org/thrift.git/lib/go/thrift/http_transport.go
generated
vendored
Normal file
34
vendor/git.apache.org/thrift.git/lib/go/thrift/http_transport.go
generated
vendored
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
/*
|
||||
* 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"
|
||||
|
||||
// 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 func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Add("Content-Type", "application/x-thrift")
|
||||
|
||||
transport := NewStreamTransport(r.Body, w)
|
||||
processor.Process(inPfactory.GetProtocol(transport), outPfactory.GetProtocol(transport))
|
||||
}
|
||||
}
|
||||
214
vendor/git.apache.org/thrift.git/lib/go/thrift/iostream_transport.go
generated
vendored
Normal file
214
vendor/git.apache.org/thrift.git/lib/go/thrift/iostream_transport.go
generated
vendored
Normal file
|
|
@ -0,0 +1,214 @@
|
|||
/*
|
||||
* 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"
|
||||
"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 {
|
||||
if trans != nil {
|
||||
t, ok := trans.(*StreamTransport)
|
||||
if ok {
|
||||
if t.isReadWriter {
|
||||
return NewStreamTransportRW(t.Reader.(io.ReadWriter))
|
||||
}
|
||||
if t.Reader != nil && t.Writer != nil {
|
||||
return NewStreamTransport(t.Reader, t.Writer)
|
||||
}
|
||||
if t.Reader != nil && t.Writer == nil {
|
||||
return NewStreamTransportR(t.Reader)
|
||||
}
|
||||
if t.Reader == nil && t.Writer != nil {
|
||||
return NewStreamTransportW(t.Writer)
|
||||
}
|
||||
return &StreamTransport{}
|
||||
}
|
||||
}
|
||||
if p.isReadWriter {
|
||||
return NewStreamTransportRW(p.Reader.(io.ReadWriter))
|
||||
}
|
||||
if p.Reader != nil && p.Writer != nil {
|
||||
return NewStreamTransport(p.Reader, p.Writer)
|
||||
}
|
||||
if p.Reader != nil && p.Writer == nil {
|
||||
return NewStreamTransportR(p.Reader)
|
||||
}
|
||||
if p.Reader == nil && p.Writer != nil {
|
||||
return NewStreamTransportW(p.Writer)
|
||||
}
|
||||
return &StreamTransport{}
|
||||
}
|
||||
|
||||
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() 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
|
||||
}
|
||||
|
||||
52
vendor/git.apache.org/thrift.git/lib/go/thrift/iostream_transport_test.go
generated
vendored
Normal file
52
vendor/git.apache.org/thrift.git/lib/go/thrift/iostream_transport_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
/*
|
||||
* 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")
|
||||
}
|
||||
}
|
||||
583
vendor/git.apache.org/thrift.git/lib/go/thrift/json_protocol.go
generated
vendored
Normal file
583
vendor/git.apache.org/thrift.git/lib/go/thrift/json_protocol.go
generated
vendored
Normal file
|
|
@ -0,0 +1,583 @@
|
|||
/*
|
||||
* 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"
|
||||
"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() (err error) {
|
||||
err = p.writer.Flush()
|
||||
if err == nil {
|
||||
err = p.trans.Flush()
|
||||
}
|
||||
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)
|
||||
}
|
||||
649
vendor/git.apache.org/thrift.git/lib/go/thrift/json_protocol_test.go
generated
vendored
Normal file
649
vendor/git.apache.org/thrift.git/lib/go/thrift/json_protocol_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,649 @@
|
|||
/*
|
||||
* 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"
|
||||
"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(); 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()
|
||||
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(); 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()
|
||||
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(); 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()
|
||||
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(); 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()
|
||||
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(); 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()
|
||||
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(); 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()
|
||||
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(); 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()
|
||||
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(); 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()
|
||||
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(); 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(); 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(); 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: %q, in go: %q", 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()
|
||||
}
|
||||
396
vendor/git.apache.org/thrift.git/lib/go/thrift/lowlevel_benchmarks_test.go
generated
vendored
Normal file
396
vendor/git.apache.org/thrift.git/lib/go/thrift/lowlevel_benchmarks_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,396 @@
|
|||
/*
|
||||
* 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 := tfv[0].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteBool(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkBinaryByte_0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteByte(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkBinaryI16_0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI16(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkBinaryI32_0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI32(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkBinaryI64_0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI64(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkBinaryDouble_0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteDouble(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkBinaryString_0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteString(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkBinaryBinary_0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteBinary(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkBinaryBool_1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteBool(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkBinaryByte_1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteByte(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkBinaryI16_1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI16(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkBinaryI32_1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI32(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkBinaryI64_1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI64(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkBinaryDouble_1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteDouble(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkBinaryString_1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteString(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkBinaryBinary_1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteBinary(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkBinaryBool_2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteBool(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkBinaryByte_2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteByte(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkBinaryI16_2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI16(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkBinaryI32_2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI32(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkBinaryI64_2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI64(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkBinaryDouble_2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteDouble(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkBinaryString_2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteString(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkBinaryBinary_2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := binaryProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteBinary(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkCompactBool_0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteBool(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkCompactByte_0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteByte(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkCompactI16_0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI16(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkCompactI32_0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI32(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkCompactI64_0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI64(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkCompactDouble0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteDouble(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkCompactString0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteString(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkCompactBinary0(b *testing.B) {
|
||||
trans := tfv[0].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteBinary(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkCompactBool_1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteBool(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkCompactByte_1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteByte(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkCompactI16_1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI16(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkCompactI32_1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI32(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkCompactI64_1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI64(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkCompactDouble1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteDouble(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkCompactString1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteString(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkCompactBinary1(b *testing.B) {
|
||||
trans := tfv[1].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteBinary(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkCompactBool_2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteBool(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkCompactByte_2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteByte(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkCompactI16_2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI16(b, p, trans)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkCompactI32_2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI32(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkCompactI64_2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteI64(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkCompactDouble2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteDouble(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkCompactString2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteString(b, p, trans)
|
||||
}
|
||||
}
|
||||
func BenchmarkCompactBinary2(b *testing.B) {
|
||||
trans := tfv[2].GetTransport(nil)
|
||||
p := compactProtoF.GetProtocol(trans)
|
||||
for i := 0; i < b.N; i++ {
|
||||
ReadWriteBinary(b, p, trans)
|
||||
}
|
||||
}
|
||||
79
vendor/git.apache.org/thrift.git/lib/go/thrift/memory_buffer.go
generated
vendored
Normal file
79
vendor/git.apache.org/thrift.git/lib/go/thrift/memory_buffer.go
generated
vendored
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
/*
|
||||
* 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"
|
||||
)
|
||||
|
||||
// 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 {
|
||||
if trans != nil {
|
||||
t, ok := trans.(*TMemoryBuffer)
|
||||
if ok && t.size > 0 {
|
||||
return NewTMemoryBufferLen(t.size)
|
||||
}
|
||||
}
|
||||
return NewTMemoryBufferLen(p.size)
|
||||
}
|
||||
|
||||
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() error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (p *TMemoryBuffer) RemainingBytes() (num_bytes uint64) {
|
||||
return uint64(p.Buffer.Len())
|
||||
}
|
||||
29
vendor/git.apache.org/thrift.git/lib/go/thrift/memory_buffer_test.go
generated
vendored
Normal file
29
vendor/git.apache.org/thrift.git/lib/go/thrift/memory_buffer_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
/*
|
||||
* 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)
|
||||
}
|
||||
31
vendor/git.apache.org/thrift.git/lib/go/thrift/messagetype.go
generated
vendored
Normal file
31
vendor/git.apache.org/thrift.git/lib/go/thrift/messagetype.go
generated
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
/*
|
||||
* 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
|
||||
)
|
||||
169
vendor/git.apache.org/thrift.git/lib/go/thrift/multiplexed_protocol.go
generated
vendored
Normal file
169
vendor/git.apache.org/thrift.git/lib/go/thrift/multiplexed_protocol.go
generated
vendored
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
/*
|
||||
* 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"
|
||||
"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(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(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(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
|
||||
}
|
||||
164
vendor/git.apache.org/thrift.git/lib/go/thrift/numeric.go
generated
vendored
Normal file
164
vendor/git.apache.org/thrift.git/lib/go/thrift/numeric.go
generated
vendored
Normal file
|
|
@ -0,0 +1,164 @@
|
|||
/*
|
||||
* 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}
|
||||
}
|
||||
50
vendor/git.apache.org/thrift.git/lib/go/thrift/pointerize.go
generated
vendored
Normal file
50
vendor/git.apache.org/thrift.git/lib/go/thrift/pointerize.go
generated
vendored
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
/*
|
||||
* 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 }
|
||||
30
vendor/git.apache.org/thrift.git/lib/go/thrift/processor.go
generated
vendored
Normal file
30
vendor/git.apache.org/thrift.git/lib/go/thrift/processor.go
generated
vendored
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
/*
|
||||
* 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
|
||||
|
||||
// A processor is a generic object which operates upon an input stream and
|
||||
// writes to some output stream.
|
||||
type TProcessor interface {
|
||||
Process(in, out TProtocol) (bool, TException)
|
||||
}
|
||||
|
||||
type TProcessorFunction interface {
|
||||
Process(seqId int32, in, out TProtocol) (bool, TException)
|
||||
}
|
||||
58
vendor/git.apache.org/thrift.git/lib/go/thrift/processor_factory.go
generated
vendored
Normal file
58
vendor/git.apache.org/thrift.git/lib/go/thrift/processor_factory.go
generated
vendored
Normal file
|
|
@ -0,0 +1,58 @@
|
|||
/*
|
||||
* 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
|
||||
|
||||
// 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
|
||||
}
|
||||
175
vendor/git.apache.org/thrift.git/lib/go/thrift/protocol.go
generated
vendored
Normal file
175
vendor/git.apache.org/thrift.git/lib/go/thrift/protocol.go
generated
vendored
Normal file
|
|
@ -0,0 +1,175 @@
|
|||
/*
|
||||
* 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"
|
||||
)
|
||||
|
||||
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() (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()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
78
vendor/git.apache.org/thrift.git/lib/go/thrift/protocol_exception.go
generated
vendored
Normal file
78
vendor/git.apache.org/thrift.git/lib/go/thrift/protocol_exception.go
generated
vendored
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
/*
|
||||
* 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()}
|
||||
}
|
||||
|
||||
25
vendor/git.apache.org/thrift.git/lib/go/thrift/protocol_factory.go
generated
vendored
Normal file
25
vendor/git.apache.org/thrift.git/lib/go/thrift/protocol_factory.go
generated
vendored
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
/*
|
||||
* 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
|
||||
}
|
||||
479
vendor/git.apache.org/thrift.git/lib/go/thrift/protocol_test.go
generated
vendored
Normal file
479
vendor/git.apache.org/thrift.git/lib/go/thrift/protocol_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,479 @@
|
|||
/*
|
||||
* 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"
|
||||
"io/ioutil"
|
||||
"math"
|
||||
"net"
|
||||
"net/http"
|
||||
"testing"
|
||||
)
|
||||
|
||||
const PROTOCOL_BINARY_DATA_SIZE = 155
|
||||
|
||||
var (
|
||||
data string // test data for writing
|
||||
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)
|
||||
}
|
||||
data = string(protocol_bdata)
|
||||
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)),
|
||||
NewTHttpPostClientTransportFactory("http://" + addr.String()),
|
||||
}
|
||||
for _, tf := range transports {
|
||||
trans := tf.GetTransport(nil)
|
||||
p := protocolFactory.GetProtocol(trans)
|
||||
ReadWriteBool(t, p, trans)
|
||||
trans.Close()
|
||||
}
|
||||
for _, tf := range transports {
|
||||
trans := tf.GetTransport(nil)
|
||||
p := protocolFactory.GetProtocol(trans)
|
||||
ReadWriteByte(t, p, trans)
|
||||
trans.Close()
|
||||
}
|
||||
for _, tf := range transports {
|
||||
trans := tf.GetTransport(nil)
|
||||
p := protocolFactory.GetProtocol(trans)
|
||||
ReadWriteI16(t, p, trans)
|
||||
trans.Close()
|
||||
}
|
||||
for _, tf := range transports {
|
||||
trans := tf.GetTransport(nil)
|
||||
p := protocolFactory.GetProtocol(trans)
|
||||
ReadWriteI32(t, p, trans)
|
||||
trans.Close()
|
||||
}
|
||||
for _, tf := range transports {
|
||||
trans := tf.GetTransport(nil)
|
||||
p := protocolFactory.GetProtocol(trans)
|
||||
ReadWriteI64(t, p, trans)
|
||||
trans.Close()
|
||||
}
|
||||
for _, tf := range transports {
|
||||
trans := tf.GetTransport(nil)
|
||||
p := protocolFactory.GetProtocol(trans)
|
||||
ReadWriteDouble(t, p, trans)
|
||||
trans.Close()
|
||||
}
|
||||
for _, tf := range transports {
|
||||
trans := tf.GetTransport(nil)
|
||||
p := protocolFactory.GetProtocol(trans)
|
||||
ReadWriteString(t, p, trans)
|
||||
trans.Close()
|
||||
}
|
||||
for _, tf := range transports {
|
||||
trans := tf.GetTransport(nil)
|
||||
p := protocolFactory.GetProtocol(trans)
|
||||
ReadWriteBinary(t, p, trans)
|
||||
trans.Close()
|
||||
}
|
||||
for _, tf := range transports {
|
||||
trans := tf.GetTransport(nil)
|
||||
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 %q Error writing bool in list at index %d: %q", "ReadWriteBool", p, trans, err, k, v)
|
||||
}
|
||||
}
|
||||
p.WriteListEnd()
|
||||
if err != nil {
|
||||
t.Errorf("%s: %T %T %q Error writing list end: %q", "ReadWriteBool", p, trans, err, BOOL_VALUES)
|
||||
}
|
||||
p.Flush()
|
||||
thetype2, thelen2, err := p.ReadListBegin()
|
||||
if err != nil {
|
||||
t.Errorf("%s: %T %T %q Error reading list: %q", "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 %s != len %s", "ReadWriteBool", p, trans, thelen, thelen2)
|
||||
}
|
||||
}
|
||||
for k, v := range BOOL_VALUES {
|
||||
value, err := p.ReadBool()
|
||||
if err != nil {
|
||||
t.Errorf("%s: %T %T %q Error reading bool at index %d: %q", "ReadWriteBool", p, trans, err, k, v)
|
||||
}
|
||||
if v != value {
|
||||
t.Errorf("%s: index %d %q %q %q != %q", "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()
|
||||
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 %s != len %s", "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()
|
||||
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 %s != len %s", "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()
|
||||
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 %s != len %s", "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()
|
||||
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 %s != len %s", "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()
|
||||
thetype2, thelen2, err := p.ReadListBegin()
|
||||
if err != nil {
|
||||
t.Errorf("%s: %T %T %q Error reading list: %q", "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 %s != len %s", "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: %q", "ReadWriteDouble", p, trans, err, k, v)
|
||||
}
|
||||
if math.IsNaN(v) {
|
||||
if !math.IsNaN(value) {
|
||||
t.Errorf("%s: %T %T math.IsNaN(%q) != math.IsNaN(%q)", "ReadWriteDouble", p, trans, v, value)
|
||||
}
|
||||
} else if v != value {
|
||||
t.Errorf("%s: %T %T %v != %q", "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()
|
||||
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 %s != len %s", "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 %d != %d", "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()
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
69
vendor/git.apache.org/thrift.git/lib/go/thrift/rich_transport.go
generated
vendored
Normal file
69
vendor/git.apache.org/thrift.git/lib/go/thrift/rich_transport.go
generated
vendored
Normal file
|
|
@ -0,0 +1,69 @@
|
|||
/*
|
||||
* 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
|
||||
}
|
||||
|
||||
85
vendor/git.apache.org/thrift.git/lib/go/thrift/rich_transport_test.go
generated
vendored
Normal file
85
vendor/git.apache.org/thrift.git/lib/go/thrift/rich_transport_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
/*
|
||||
* 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 := tf.GetTransport(nil)
|
||||
_, 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
|
||||
}
|
||||
75
vendor/git.apache.org/thrift.git/lib/go/thrift/serializer.go
generated
vendored
Normal file
75
vendor/git.apache.org/thrift.git/lib/go/thrift/serializer.go
generated
vendored
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
/*
|
||||
* 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 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(msg TStruct) (s string, err error) {
|
||||
t.Transport.Reset()
|
||||
|
||||
if err = msg.Write(t.Protocol); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if err = t.Protocol.Flush(); err != nil {
|
||||
return
|
||||
}
|
||||
if err = t.Transport.Flush(); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
return t.Transport.String(), nil
|
||||
}
|
||||
|
||||
func (t *TSerializer) Write(msg TStruct) (b []byte, err error) {
|
||||
t.Transport.Reset()
|
||||
|
||||
if err = msg.Write(t.Protocol); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if err = t.Protocol.Flush(); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if err = t.Transport.Flush(); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
b = append(b, t.Transport.Bytes()...)
|
||||
return
|
||||
}
|
||||
169
vendor/git.apache.org/thrift.git/lib/go/thrift/serializer_test.go
generated
vendored
Normal file
169
vendor/git.apache.org/thrift.git/lib/go/thrift/serializer_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
/*
|
||||
* 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"
|
||||
"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(&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(&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)
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
633
vendor/git.apache.org/thrift.git/lib/go/thrift/serializer_types_test.go
generated
vendored
Normal file
633
vendor/git.apache.org/thrift.git/lib/go/thrift/serializer_types_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,633 @@
|
|||
/*
|
||||
* 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 (1.0.0-dev)
|
||||
// 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)
|
||||
}
|
||||
35
vendor/git.apache.org/thrift.git/lib/go/thrift/server.go
generated
vendored
Normal file
35
vendor/git.apache.org/thrift.git/lib/go/thrift/server.go
generated
vendored
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
/*
|
||||
* 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
|
||||
}
|
||||
122
vendor/git.apache.org/thrift.git/lib/go/thrift/server_socket.go
generated
vendored
Normal file
122
vendor/git.apache.org/thrift.git/lib/go/thrift/server_socket.go
generated
vendored
Normal file
|
|
@ -0,0 +1,122 @@
|
|||
/*
|
||||
* 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
|
||||
}
|
||||
|
||||
func (p *TServerSocket) Listen() error {
|
||||
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
|
||||
}
|
||||
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 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 {
|
||||
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 {
|
||||
defer func() {
|
||||
p.listener = nil
|
||||
}()
|
||||
if p.IsListening() {
|
||||
return p.listener.Close()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (p *TServerSocket) Interrupt() error {
|
||||
p.mu.Lock()
|
||||
p.interrupted = true
|
||||
p.Close()
|
||||
p.mu.Unlock()
|
||||
|
||||
return nil
|
||||
}
|
||||
50
vendor/git.apache.org/thrift.git/lib/go/thrift/server_socket_test.go
generated
vendored
Normal file
50
vendor/git.apache.org/thrift.git/lib/go/thrift/server_socket_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
/*
|
||||
* 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 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
|
||||
}
|
||||
28
vendor/git.apache.org/thrift.git/lib/go/thrift/server_test.go
generated
vendored
Normal file
28
vendor/git.apache.org/thrift.git/lib/go/thrift/server_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
/*
|
||||
* 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) {
|
||||
|
||||
}
|
||||
34
vendor/git.apache.org/thrift.git/lib/go/thrift/server_transport.go
generated
vendored
Normal file
34
vendor/git.apache.org/thrift.git/lib/go/thrift/server_transport.go
generated
vendored
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
/*
|
||||
* 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
|
||||
}
|
||||
1337
vendor/git.apache.org/thrift.git/lib/go/thrift/simple_json_protocol.go
generated
vendored
Normal file
1337
vendor/git.apache.org/thrift.git/lib/go/thrift/simple_json_protocol.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
715
vendor/git.apache.org/thrift.git/lib/go/thrift/simple_json_protocol_test.go
generated
vendored
Normal file
715
vendor/git.apache.org/thrift.git/lib/go/thrift/simple_json_protocol_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,715 @@
|
|||
/*
|
||||
* 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"
|
||||
"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(); 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()
|
||||
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(); 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()
|
||||
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(); 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()
|
||||
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(); 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()
|
||||
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()
|
||||
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(); 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()
|
||||
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()
|
||||
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(); 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()
|
||||
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(); 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()
|
||||
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()
|
||||
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(); 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()
|
||||
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()
|
||||
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(); 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(); 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(); 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: %q, in go: %q", 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()
|
||||
}
|
||||
191
vendor/git.apache.org/thrift.git/lib/go/thrift/simple_server.go
generated
vendored
Normal file
191
vendor/git.apache.org/thrift.git/lib/go/thrift/simple_server.go
generated
vendored
Normal file
|
|
@ -0,0 +1,191 @@
|
|||
/*
|
||||
* 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/atomic"
|
||||
)
|
||||
|
||||
// Simple, non-concurrent server for testing.
|
||||
type TSimpleServer struct {
|
||||
quit chan struct{}
|
||||
stopped int64
|
||||
|
||||
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,
|
||||
quit: make(chan struct{}, 1),
|
||||
}
|
||||
}
|
||||
|
||||
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) AcceptLoop() error {
|
||||
for {
|
||||
client, err := p.serverTransport.Accept()
|
||||
if err != nil {
|
||||
select {
|
||||
case <-p.quit:
|
||||
return nil
|
||||
default:
|
||||
}
|
||||
return err
|
||||
}
|
||||
if client != nil {
|
||||
go func() {
|
||||
if err := p.processRequests(client); err != nil {
|
||||
log.Println("error processing request:", err)
|
||||
}
|
||||
}()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (p *TSimpleServer) Serve() error {
|
||||
err := p.Listen()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
p.AcceptLoop()
|
||||
return nil
|
||||
}
|
||||
|
||||
func (p *TSimpleServer) Stop() error {
|
||||
if atomic.CompareAndSwapInt64(&p.stopped, 0, 1) {
|
||||
p.quit <- struct{}{}
|
||||
p.serverTransport.Interrupt()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (p *TSimpleServer) processRequests(client TTransport) error {
|
||||
processor := p.processorFactory.GetProcessor(client)
|
||||
inputTransport := p.inputTransportFactory.GetTransport(client)
|
||||
outputTransport := p.outputTransportFactory.GetTransport(client)
|
||||
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 {
|
||||
ok, err := processor.Process(inputProtocol, outputProtocol)
|
||||
if err, ok := err.(TTransportException); ok && err.TypeId() == END_OF_FILE {
|
||||
return nil
|
||||
} else if err != nil {
|
||||
log.Printf("error processing request: %s", err)
|
||||
return err
|
||||
}
|
||||
if !ok {
|
||||
break
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
166
vendor/git.apache.org/thrift.git/lib/go/thrift/socket.go
generated
vendored
Normal file
166
vendor/git.apache.org/thrift.git/lib/go/thrift/socket.go
generated
vendored
Normal file
|
|
@ -0,0 +1,166 @@
|
|||
/*
|
||||
* 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"
|
||||
"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() 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
|
||||
}
|
||||
|
||||
109
vendor/git.apache.org/thrift.git/lib/go/thrift/ssl_server_socket.go
generated
vendored
Normal file
109
vendor/git.apache.org/thrift.git/lib/go/thrift/ssl_server_socket.go
generated
vendored
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
/*
|
||||
* 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"
|
||||
"time"
|
||||
"crypto/tls"
|
||||
)
|
||||
|
||||
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) {
|
||||
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
|
||||
}
|
||||
171
vendor/git.apache.org/thrift.git/lib/go/thrift/ssl_socket.go
generated
vendored
Normal file
171
vendor/git.apache.org/thrift.git/lib/go/thrift/ssl_socket.go
generated
vendored
Normal file
|
|
@ -0,0 +1,171 @@
|
|||
/*
|
||||
* 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 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) {
|
||||
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.Dial("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.Dial(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() 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
|
||||
}
|
||||
|
||||
68
vendor/git.apache.org/thrift.git/lib/go/thrift/transport.go
generated
vendored
Normal file
68
vendor/git.apache.org/thrift.git/lib/go/thrift/transport.go
generated
vendored
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
/*
|
||||
* 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"
|
||||
)
|
||||
|
||||
var errTransportInterrupted = errors.New("Transport Interrupted")
|
||||
|
||||
type Flusher interface {
|
||||
Flush() (err error)
|
||||
}
|
||||
|
||||
type ReadSizeProvider interface {
|
||||
RemainingBytes() (num_bytes uint64)
|
||||
}
|
||||
|
||||
|
||||
// Encapsulates the I/O layer
|
||||
type TTransport interface {
|
||||
io.ReadWriteCloser
|
||||
Flusher
|
||||
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
|
||||
Flusher
|
||||
ReadSizeProvider
|
||||
}
|
||||
|
||||
90
vendor/git.apache.org/thrift.git/lib/go/thrift/transport_exception.go
generated
vendored
Normal file
90
vendor/git.apache.org/thrift.git/lib/go/thrift/transport_exception.go
generated
vendored
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
/*
|
||||
* 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}
|
||||
}
|
||||
60
vendor/git.apache.org/thrift.git/lib/go/thrift/transport_exception_test.go
generated
vendored
Normal file
60
vendor/git.apache.org/thrift.git/lib/go/thrift/transport_exception_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
/*
|
||||
* 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())
|
||||
}
|
||||
}
|
||||
39
vendor/git.apache.org/thrift.git/lib/go/thrift/transport_factory.go
generated
vendored
Normal file
39
vendor/git.apache.org/thrift.git/lib/go/thrift/transport_factory.go
generated
vendored
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
/*
|
||||
* 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
|
||||
}
|
||||
|
||||
type tTransportFactory struct{}
|
||||
|
||||
// Return a wrapped instance of the base Transport.
|
||||
func (p *tTransportFactory) GetTransport(trans TTransport) TTransport {
|
||||
return trans
|
||||
}
|
||||
|
||||
func NewTTransportFactory() TTransportFactory {
|
||||
return &tTransportFactory{}
|
||||
}
|
||||
176
vendor/git.apache.org/thrift.git/lib/go/thrift/transport_test.go
generated
vendored
Normal file
176
vendor/git.apache.org/thrift.git/lib/go/thrift/transport_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,176 @@
|
|||
/*
|
||||
* 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"
|
||||
"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()
|
||||
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()
|
||||
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()
|
||||
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
|
||||
}
|
||||
69
vendor/git.apache.org/thrift.git/lib/go/thrift/type.go
generated
vendored
Normal file
69
vendor/git.apache.org/thrift.git/lib/go/thrift/type.go
generated
vendored
Normal file
|
|
@ -0,0 +1,69 @@
|
|||
/*
|
||||
* 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 constants in the Thrift protocol
|
||||
type TType byte
|
||||
|
||||
const (
|
||||
STOP = 0
|
||||
VOID = 1
|
||||
BOOL = 2
|
||||
BYTE = 3
|
||||
I08 = 3
|
||||
DOUBLE = 4
|
||||
I16 = 6
|
||||
I32 = 8
|
||||
I64 = 10
|
||||
STRING = 11
|
||||
UTF7 = 11
|
||||
STRUCT = 12
|
||||
MAP = 13
|
||||
SET = 14
|
||||
LIST = 15
|
||||
UTF8 = 16
|
||||
UTF16 = 17
|
||||
//BINARY = 18 wrong and unusued
|
||||
)
|
||||
|
||||
var typeNames = map[int]string{
|
||||
STOP: "STOP",
|
||||
VOID: "VOID",
|
||||
BOOL: "BOOL",
|
||||
BYTE: "BYTE",
|
||||
DOUBLE: "DOUBLE",
|
||||
I16: "I16",
|
||||
I32: "I32",
|
||||
I64: "I64",
|
||||
STRING: "STRING",
|
||||
STRUCT: "STRUCT",
|
||||
MAP: "MAP",
|
||||
SET: "SET",
|
||||
LIST: "LIST",
|
||||
UTF8: "UTF8",
|
||||
UTF16: "UTF16",
|
||||
}
|
||||
|
||||
func (p TType) String() string {
|
||||
if s, ok := typeNames[int(p)]; ok {
|
||||
return s
|
||||
}
|
||||
return "Unknown"
|
||||
}
|
||||
117
vendor/git.apache.org/thrift.git/lib/go/thrift/zlib_transport.go
generated
vendored
Normal file
117
vendor/git.apache.org/thrift.git/lib/go/thrift/zlib_transport.go
generated
vendored
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
/*
|
||||
* 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/zlib"
|
||||
"io"
|
||||
"log"
|
||||
)
|
||||
|
||||
// TZlibTransportFactory is a factory for TZlibTransport instances
|
||||
type TZlibTransportFactory struct {
|
||||
level int
|
||||
}
|
||||
|
||||
// TZlibTransport is a TTransport implementation that makes use of zlib compression.
|
||||
type TZlibTransport struct {
|
||||
reader io.ReadCloser
|
||||
transport TTransport
|
||||
writer *zlib.Writer
|
||||
}
|
||||
|
||||
// GetTransport constructs a new instance of NewTZlibTransport
|
||||
func (p *TZlibTransportFactory) GetTransport(trans TTransport) TTransport {
|
||||
t, _ := NewTZlibTransport(trans, p.level)
|
||||
return t
|
||||
}
|
||||
|
||||
// NewTZlibTransportFactory constructs a new instance of NewTZlibTransportFactory
|
||||
func NewTZlibTransportFactory(level int) *TZlibTransportFactory {
|
||||
return &TZlibTransportFactory{level: level}
|
||||
}
|
||||
|
||||
// NewTZlibTransport constructs a new instance of TZlibTransport
|
||||
func NewTZlibTransport(trans TTransport, level int) (*TZlibTransport, error) {
|
||||
w, err := zlib.NewWriterLevel(trans, level)
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &TZlibTransport{
|
||||
writer: w,
|
||||
transport: trans,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Close closes the reader and writer (flushing any unwritten data) and closes
|
||||
// the underlying transport.
|
||||
func (z *TZlibTransport) Close() error {
|
||||
if z.reader != nil {
|
||||
if err := z.reader.Close(); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if err := z.writer.Close(); err != nil {
|
||||
return err
|
||||
}
|
||||
return z.transport.Close()
|
||||
}
|
||||
|
||||
// Flush flushes the writer and its underlying transport.
|
||||
func (z *TZlibTransport) Flush() error {
|
||||
if err := z.writer.Flush(); err != nil {
|
||||
return err
|
||||
}
|
||||
return z.transport.Flush()
|
||||
}
|
||||
|
||||
// IsOpen returns true if the transport is open
|
||||
func (z *TZlibTransport) IsOpen() bool {
|
||||
return z.transport.IsOpen()
|
||||
}
|
||||
|
||||
// Open opens the transport for communication
|
||||
func (z *TZlibTransport) Open() error {
|
||||
return z.transport.Open()
|
||||
}
|
||||
|
||||
func (z *TZlibTransport) Read(p []byte) (int, error) {
|
||||
if z.reader == nil {
|
||||
r, err := zlib.NewReader(z.transport)
|
||||
if err != nil {
|
||||
return 0, NewTTransportExceptionFromError(err)
|
||||
}
|
||||
z.reader = r
|
||||
}
|
||||
|
||||
return z.reader.Read(p)
|
||||
}
|
||||
|
||||
// RemainingBytes returns the size in bytes of the data that is still to be
|
||||
// read.
|
||||
func (z *TZlibTransport) RemainingBytes() uint64 {
|
||||
return z.transport.RemainingBytes()
|
||||
}
|
||||
|
||||
func (z *TZlibTransport) Write(p []byte) (int, error) {
|
||||
return z.writer.Write(p)
|
||||
}
|
||||
33
vendor/git.apache.org/thrift.git/lib/go/thrift/zlib_transport_test.go
generated
vendored
Normal file
33
vendor/git.apache.org/thrift.git/lib/go/thrift/zlib_transport_test.go
generated
vendored
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
/*
|
||||
* 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/zlib"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestZlibTransport(t *testing.T) {
|
||||
trans, err := NewTZlibTransport(NewTMemoryBuffer(), zlib.BestCompression)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
TransportTest(t, trans, trans)
|
||||
}
|
||||
18
vendor/vendor.json
vendored
Normal file
18
vendor/vendor.json
vendored
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
{
|
||||
"comment": "",
|
||||
"ignore": "",
|
||||
"package": [
|
||||
{
|
||||
"checksumSHA1": "ok7Zbwi2IVOuN4hKybLLU9CjsQI=",
|
||||
"path": "errors",
|
||||
"revision": ""
|
||||
},
|
||||
{
|
||||
"checksumSHA1": "6Lb7h/mj8rBtSQPV1O3RxxfBvNE=",
|
||||
"path": "git.apache.org/thrift.git/lib/go/thrift",
|
||||
"revision": "bcad91771b7f0bff28a1cac1981d7ef2b9bcef3c",
|
||||
"revisionTime": "2016-07-24T10:11:25Z"
|
||||
}
|
||||
],
|
||||
"rootPath": "github.com/rdelval/gorealis"
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue