)
type TBinaryProtocol struct {
- trans TTransport
- strictRead bool
- strictWrite bool
- buffer [8]byte
+ trans TRichTransport
+ origTransport TTransport
+ reader io.Reader
+ writer io.Writer
+ strictRead bool
+ strictWrite bool
+ buffer [64]byte
}
type TBinaryProtocolFactory struct {
}
func NewTBinaryProtocol(t TTransport, strictRead, strictWrite bool) *TBinaryProtocol {
- return &TBinaryProtocol{trans: t, strictRead: strictRead, strictWrite: strictWrite}
+ 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 {
}
func (p *TBinaryProtocol) WriteByte(value byte) error {
- v := []byte{value}
- _, e := p.trans.Write(v)
+ e := p.trans.WriteByte(value)
return NewTProtocolException(e)
}
func (p *TBinaryProtocol) WriteI16(value int16) error {
v := p.buffer[0:2]
binary.BigEndian.PutUint16(v, uint16(value))
- _, e := p.trans.Write(v)
+ _, 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.trans.Write(v)
+ _, e := p.writer.Write(v)
return NewTProtocolException(e)
}
func (p *TBinaryProtocol) WriteI64(value int64) error {
- v := p.buffer[:]
+ v := p.buffer[0:8]
binary.BigEndian.PutUint64(v, uint64(value))
- _, err := p.trans.Write(v)
+ _, err := p.writer.Write(v)
return NewTProtocolException(err)
}
}
func (p *TBinaryProtocol) WriteString(value string) error {
- return p.WriteBinary([]byte(value))
+ 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 {
if e != nil {
return e
}
- _, err := p.trans.Write(value)
+ _, err := p.writer.Write(value)
return NewTProtocolException(err)
}
}
func (p *TBinaryProtocol) ReadByte() (value byte, err error) {
- buf := p.buffer[0:1]
- err = p.readAll(buf)
- return buf[0], err
+ return p.trans.ReadByte()
}
func (p *TBinaryProtocol) ReadI16() (value int16, err error) {
}
func (p *TBinaryProtocol) Transport() TTransport {
- return p.trans
+ return p.origTransport
}
func (p *TBinaryProtocol) readAll(buf []byte) error {
- _, err := io.ReadFull(p.trans, buf)
+ _, err := io.ReadFull(p.reader, buf)
return NewTProtocolException(err)
}
if size < 0 {
return "", nil
}
- isize := int(size)
- buf := make([]byte, isize)
+ var buf []byte
+ if size <= len(p.buffer) {
+ buf = p.buffer[0:size]
+ } else {
+ buf = make([]byte, size)
+ }
_, e := io.ReadFull(p.trans, buf)
return string(buf), NewTProtocolException(e)
}
package thrift
+import (
+ "bufio"
+)
+
type TBufferedTransportFactory struct {
size int
}
-type TBuffer struct {
- buffer []byte
- pos, limit int
-}
-
type TBufferedTransport struct {
- tp TTransport
- rbuf *TBuffer
- wbuf *TBuffer
+ bufio.ReadWriter
+ tp TTransport
}
func (p *TBufferedTransportFactory) GetTransport(trans TTransport) TTransport {
}
func NewTBufferedTransport(trans TTransport, bufferSize int) *TBufferedTransport {
- rb := &TBuffer{buffer: make([]byte, bufferSize)}
- wb := &TBuffer{buffer: make([]byte, bufferSize), limit: bufferSize}
- return &TBufferedTransport{tp: trans, rbuf: rb, wbuf: wb}
+ 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.Close()
}
-func (p *TBufferedTransport) Read(buf []byte) (n int, err error) {
- rbuf := p.rbuf
- if rbuf.pos == rbuf.limit { // no more data to read from buffer
- rbuf.pos = 0
- // read data, fill buffer
- rbuf.limit, err = p.tp.Read(rbuf.buffer)
- if err != nil {
- return 0, err
- }
- }
- n = copy(buf, rbuf.buffer[rbuf.pos:rbuf.limit])
- rbuf.pos += n
- return n, nil
-}
-
-func (p *TBufferedTransport) Write(buf []byte) (n int, err error) {
- wbuf := p.wbuf
- remaining := len(buf)
-
- for remaining > 0 {
- if wbuf.pos+remaining > wbuf.limit { // buffer is full, flush buffer
- if err := p.Flush(); err != nil {
- return n, err
- }
- }
- copied := copy(wbuf.buffer[wbuf.pos:], buf[n:])
-
- wbuf.pos += copied
- n += copied
- remaining -= copied
- }
-
- return n, nil
-}
-
func (p *TBufferedTransport) Flush() error {
- start := 0
- wbuf := p.wbuf
- for start < wbuf.pos {
- n, err := p.tp.Write(wbuf.buffer[start:wbuf.pos])
- if err != nil {
- return err
- }
- start += n
+ if err := p.ReadWriter.Flush(); err != nil {
+ return err
}
-
- wbuf.pos = 0
return p.tp.Flush()
}
-
-func (p *TBufferedTransport) Peek() bool {
- return p.rbuf.pos < p.rbuf.limit || p.tp.Peek()
-}
"fmt"
"io"
"math"
- "strings"
)
const (
}
type TCompactProtocol struct {
- trans TTransport
+ 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.
// If we encounter a boolean field begin, save the TField here so it can
// have the value incorporated.
- booleanField *field
+ 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 {
- return &TCompactProtocol{trans: trans, lastField: []int{}}
+ p := &TCompactProtocol{origTransport: trans, lastField: []int{}}
+ if et, ok := trans.(TRichTransport); ok {
+ p.trans = et
+ } else {
+ p.trans = NewTRichTransport(trans)
+ }
+
+ return p
+
}
//
// 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)
+ 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))
+ err = p.writeByteDirect((COMPACT_VERSION & COMPACT_VERSION_MASK) | ((byte(typeId) << COMPACT_TYPE_SHIFT_AMOUNT) & COMPACT_TYPE_MASK))
if err != nil {
return NewTProtocolException(err)
}
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.booleanField = newField(name, typeId, int(id))
+ p.booleanFieldName, p.booleanFieldId, p.booleanFieldPending = name, id, true
return nil
}
_, err := p.writeFieldBeginInternal(name, typeId, id, 0xFF)
written := 0
if fieldId > p.lastFieldId && fieldId-p.lastFieldId <= 15 {
// write them together
- written, err := p.writeByteDirect(byte((fieldId-p.lastFieldId)<<4) | typeToWrite)
+ err := p.writeByteDirect(byte((fieldId-p.lastFieldId)<<4) | typeToWrite)
if err != nil {
- return written, err
+ return 0, err
}
} else {
// write them separate
- n, err := p.writeByteDirect(typeToWrite)
+ err := p.writeByteDirect(typeToWrite)
if err != nil {
- return n, err
+ return 0, err
}
err = p.WriteI16(id)
- written = n + 2
+ written = 1 + 2
if err != nil {
- return written, err
+ return 0, err
}
}
func (p *TCompactProtocol) WriteFieldEnd() error { return nil }
func (p *TCompactProtocol) WriteFieldStop() error {
- _, err := p.writeByteDirect(STOP)
+ 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)
+ 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)))
+ err = p.writeByteDirect(byte(p.getCompactType(keyType))<<4 | byte(p.getCompactType(valueType)))
return NewTProtocolException(err)
}
if value {
v = byte(COMPACT_BOOLEAN_TRUE)
}
- if p.booleanField != nil {
+ if p.booleanFieldPending {
// we haven't written the field header yet
- _, err := p.writeFieldBeginInternal(p.booleanField.Name(), p.booleanField.TypeId(), int16(p.booleanField.Id()), v)
- p.booleanField = nil
+ _, 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)
+ err := p.writeByteDirect(v)
return NewTProtocolException(err)
}
// Write a byte. Nothing to see here!
func (p *TCompactProtocol) WriteByte(value byte) error {
- _, err := p.writeByteDirect(value)
+ err := p.writeByteDirect(value)
return NewTProtocolException(err)
}
// Write a double to the wire as 8 bytes.
func (p *TCompactProtocol) WriteDouble(value float64) error {
- buf := make([]byte, 8)
+ 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 preceeding.
func (p *TCompactProtocol) WriteString(value string) error {
- buf := make([]byte, len(value))
- strings.NewReader(value).Read(buf)
- return p.WriteBinary(buf)
+ _, 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.
// if it's a stop, then we can return immediately, as the struct is over.
if (t & 0x0f) == STOP {
- return "", STOP, 0,nil
+ return "", STOP, 0, nil
}
// mask off the 4 MSB of the type header. it could contain a field id delta.
// Read a single byte off the wire. Nothing interesting here.
func (p *TCompactProtocol) ReadByte() (value byte, err error) {
- buf := []byte{0}
- _, e := io.ReadFull(p.trans, buf)
- if e != nil {
- return 0, NewTProtocolException(e)
+ value, err = p.trans.ReadByte()
+ if err != nil {
+ return 0, NewTProtocolException(err)
}
- return buf[0], nil
+ return
}
// Read an i16 from the wire as a zigzag varint.
// No magic here - just read a double off the wire.
func (p *TCompactProtocol) ReadDouble() (value float64, err error) {
- longBits := make([]byte, 8)
+ longBits := p.buffer[0:8]
_, e := io.ReadFull(p.trans, longBits)
if e != nil {
return 0.0, NewTProtocolException(e)
// Reads a []byte (via readBinary), and then UTF-8 decodes it.
func (p *TCompactProtocol) ReadString() (value string, err error) {
- v, e := p.ReadBinary()
- return string(v), NewTProtocolException(e)
+ length, e := p.readVarint32()
+ if e != nil {
+ return "", NewTProtocolException(e)
+ }
+ 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 []byte{}, NewTProtocolException(e)
+ return nil, NewTProtocolException(e)
}
if length == 0 {
- return []byte{}, nil
+ return nil, nil //nil == empty slice
}
buf := make([]byte, length)
}
func (p *TCompactProtocol) Transport() TTransport {
- return p.trans
+ return p.origTransport
}
//
// the wire differ only by the type indicator.
func (p *TCompactProtocol) writeCollectionBegin(elemType TType, size int) (int, error) {
if size <= 14 {
- return p.writeByteDirect(byte(int32(size<<4) | int32(p.getCompactType(elemType))))
+ return 1, p.writeByteDirect(byte(int32(size<<4) | int32(p.getCompactType(elemType))))
}
- n, err := p.writeByteDirect(0xf0 | byte(p.getCompactType(elemType)))
+ err := p.writeByteDirect(0xf0 | byte(p.getCompactType(elemType)))
if err != nil {
- return n, err
+ return 0, err
}
m, err := p.writeVarint32(int32(size))
- return n + m, err
+ 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 := make([]byte, 5)
+ i32buf := p.buffer[0:5]
idx := 0
for {
if (n & ^0x7F) == 0 {
// Write an i64 as a varint. Results in 1-10 bytes on the wire.
func (p *TCompactProtocol) writeVarint64(n int64) (int, error) {
- varint64out := make([]byte, 10)
+ varint64out := p.buffer[0:10]
idx := 0
for {
if (n & ^0x7F) == 0 {
// Writes a byte without any possiblity 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) (int, error) {
- return p.trans.Write([]byte{b})
+func (p *TCompactProtocol) writeByteDirect(b byte) error {
+ return p.trans.WriteByte(b)
}
// Writes a byte without any possiblity of all that field header nonsense.
func (p *TCompactProtocol) writeIntAsByteDirect(n int) (int, error) {
- return p.writeByteDirect(byte(n))
+ return 1, p.writeByteDirect(byte(n))
}
//
package thrift
import (
+ "bufio"
"bytes"
"encoding/binary"
+ "fmt"
"io"
)
+const DEFAULT_MAX_LENGTH = 16384000
+
type TFramedTransport struct {
- transport TTransport
- writeBuffer *bytes.Buffer
- readBuffer *bytes.Buffer
+ transport TTransport
+ buf bytes.Buffer
+ reader *bufio.Reader
+ frameSize int //Current remaining size of the frame. if ==0 read next frame header
+ buffer [4]byte
+ maxLength int
}
type tFramedTransportFactory struct {
- factory TTransportFactory
+ factory TTransportFactory
+ maxLength int
}
func NewTFramedTransportFactory(factory TTransportFactory) TTransportFactory {
- return &tFramedTransportFactory{factory: factory}
+ return &tFramedTransportFactory{factory: factory, maxLength: DEFAULT_MAX_LENGTH}
}
func (p *tFramedTransportFactory) GetTransport(base TTransport) TTransport {
- return NewTFramedTransport(p.factory.GetTransport(base))
+ return NewTFramedTransportMaxLength(p.factory.GetTransport(base), p.maxLength)
}
func NewTFramedTransport(transport TTransport) *TFramedTransport {
- writeBuf := make([]byte, 0, 1024)
- readBuf := make([]byte, 0, 1024)
- return &TFramedTransport{transport: transport, writeBuffer: bytes.NewBuffer(writeBuf), readBuffer: bytes.NewBuffer(readBuf)}
+ return &TFramedTransport{transport: transport, reader: bufio.NewReader(transport), maxLength: DEFAULT_MAX_LENGTH}
+}
+
+func NewTFramedTransportMaxLength(transport TTransport, maxLength int) *TFramedTransport {
+ return &TFramedTransport{transport: transport, reader: bufio.NewReader(transport), maxLength: maxLength}
}
func (p *TFramedTransport) Open() error {
return p.transport.IsOpen()
}
-func (p *TFramedTransport) Peek() bool {
- return p.transport.Peek()
-}
-
func (p *TFramedTransport) Close() error {
return p.transport.Close()
}
-func (p *TFramedTransport) Read(buf []byte) (int, error) {
- if p.readBuffer.Len() > 0 {
- got, err := p.readBuffer.Read(buf)
- if got > 0 {
- return got, NewTTransportExceptionFromError(err)
+func (p *TFramedTransport) Read(buf []byte) (l int, err error) {
+ if p.frameSize == 0 {
+ p.frameSize, err = p.readFrameHeader()
+ if err != nil {
+ return
}
}
-
- // Read another frame of data
- p.readFrame()
-
- got, err := p.readBuffer.Read(buf)
+ if p.frameSize < len(buf) {
+ return 0, NewTTransportExceptionFromError(fmt.Errorf("Not enought frame size %d to read %d bytes", p.frameSize, len(buf)))
+ }
+ got, err := p.reader.Read(buf)
+ p.frameSize = p.frameSize - 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 enought 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.writeBuffer.Write(buf)
+ 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.writeBuffer.Len()
- buf := []byte{0, 0, 0, 0}
+ 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.writeBuffer.WriteTo(p.transport); err != nil {
+ 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)
}
return NewTTransportExceptionFromError(err)
}
-func (p *TFramedTransport) readFrame() (int, error) {
- buf := []byte{0, 0, 0, 0}
- if _, err := io.ReadFull(p.transport, buf); err != nil {
+func (p *TFramedTransport) readFrameHeader() (int, error) {
+ buf := p.buffer[:4]
+ if _, err := io.ReadFull(p.reader, buf); err != nil {
return 0, err
}
size := int(binary.BigEndian.Uint32(buf))
- if size < 0 {
- return 0, NewTTransportException(UNKNOWN_TRANSPORT_EXCEPTION, "Read a negative frame size ("+string(size)+")")
- }
- if size == 0 {
- return 0, nil
- }
- buf2 := make([]byte, size)
- if n, err := io.ReadFull(p.transport, buf2); err != nil {
- return n, err
+ if size < 0 || size > p.maxLength {
+ return 0, NewTTransportException(UNKNOWN_TRANSPORT_EXCEPTION, fmt.Sprintf("Incorrect frame size (%d)", size))
}
- p.readBuffer = bytes.NewBuffer(buf2)
return size, 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 {
client := &http.Client{}
req, err := http.NewRequest("POST", p.url.String(), p.requestBuffer)
// StreamTransport is a Transport made of an io.Reader and/or an io.Writer
type StreamTransport struct {
- Reader io.Reader
- Writer io.Writer
+ io.Reader
+ io.Writer
isReadWriter bool
}
return nil
}
-func (p *StreamTransport) Peek() bool {
- return p.IsOpen()
-}
+// func (p *StreamTransport) Peek() bool {
+// return p.IsOpen()
+// }
// Closes both the input and output streams.
func (p *StreamTransport) Close() error {
return nil
}
-// Reads from the underlying input stream if not null.
-func (p *StreamTransport) Read(buf []byte) (int, error) {
- if p.Reader == nil {
- return 0, NewTTransportException(NOT_OPEN, "Cannot read from null inputStream")
- }
- n, err := p.Reader.Read(buf)
- return n, NewTTransportExceptionFromError(err)
-}
-
-// Writes to the underlying output stream if not null.
-func (p *StreamTransport) Write(buf []byte) (int, error) {
- if p.Writer == nil {
- return 0, NewTTransportException(NOT_OPEN, "Cannot write to null outputStream")
- }
- n, err := p.Writer.Write(buf)
- return n, NewTTransportExceptionFromError(err)
-}
-
// Flushes the underlying output stream if not null.
func (p *StreamTransport) Flush() error {
if p.Writer == nil {
}
return nil
}
+
+func (p *StreamTransport) ReadByte() (c byte, err error) {
+ f, ok := p.Reader.(io.ByteReader)
+ if ok {
+ return f.ReadByte()
+ }
+ return readByte(p.Reader)
+}
+
+func (p *StreamTransport) WriteByte(c byte) error {
+ f, ok := p.Writer.(io.ByteWriter)
+ if ok {
+ return f.WriteByte(c)
+ }
+ return writeByte(p.Writer, c)
+}
+
+func (p *StreamTransport) WriteString(s string) (n int, err error) {
+ f, ok := p.Writer.(stringWriter)
+ if ok {
+ return f.WriteString(s)
+ }
+ return p.Writer.Write([]byte(s))
+}
--- /dev/null
+/*
+ * 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)
+ }
+}
}
-func ReadWriteBool(t *testing.T, p TProtocol, trans TTransport) {
+func ReadWriteBool(t testing.TB, p TProtocol, trans TTransport) {
thetype := TType(BOOL)
thelen := len(BOOL_VALUES)
err := p.WriteListBegin(thetype, thelen)
}
}
-func ReadWriteByte(t *testing.T, p TProtocol, trans TTransport) {
+func ReadWriteByte(t testing.TB, p TProtocol, trans TTransport) {
thetype := TType(BYTE)
thelen := len(BYTE_VALUES)
err := p.WriteListBegin(thetype, thelen)
}
}
-func ReadWriteI16(t *testing.T, p TProtocol, trans TTransport) {
+func ReadWriteI16(t testing.TB, p TProtocol, trans TTransport) {
thetype := TType(I16)
thelen := len(INT16_VALUES)
p.WriteListBegin(thetype, thelen)
}
}
-func ReadWriteI32(t *testing.T, p TProtocol, trans TTransport) {
+func ReadWriteI32(t testing.TB, p TProtocol, trans TTransport) {
thetype := TType(I32)
thelen := len(INT32_VALUES)
p.WriteListBegin(thetype, thelen)
}
}
-func ReadWriteI64(t *testing.T, p TProtocol, trans TTransport) {
+func ReadWriteI64(t testing.TB, p TProtocol, trans TTransport) {
thetype := TType(I64)
thelen := len(INT64_VALUES)
p.WriteListBegin(thetype, thelen)
}
}
-func ReadWriteDouble(t *testing.T, p TProtocol, trans TTransport) {
+func ReadWriteDouble(t testing.TB, p TProtocol, trans TTransport) {
thetype := TType(DOUBLE)
thelen := len(DOUBLE_VALUES)
p.WriteListBegin(thetype, thelen)
}
p.WriteListEnd()
p.Flush()
- wrotebuffer := ""
- if memtrans, ok := trans.(*TMemoryBuffer); ok {
- wrotebuffer = memtrans.String()
- }
thetype2, thelen2, err := p.ReadListBegin()
if err != nil {
- t.Errorf("%s: %T %T %q Error reading list: %q, wrote: %v", "ReadWriteDouble", p, trans, err, DOUBLE_VALUES, wrotebuffer)
+ 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)
}
}
-func ReadWriteString(t *testing.T, p TProtocol, trans TTransport) {
+func ReadWriteString(t testing.TB, p TProtocol, trans TTransport) {
thetype := TType(STRING)
thelen := len(STRING_VALUES)
p.WriteListBegin(thetype, thelen)
}
}
-func ReadWriteBinary(t *testing.T, p TProtocol, trans TTransport) {
+func ReadWriteBinary(t testing.TB, p TProtocol, trans TTransport) {
v := protocol_bdata
p.WriteBinary(v)
p.Flush()
--- /dev/null
+/*
+ * 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 readByte(r io.Reader) (c byte, err error) {
+ v := [1]byte{0}
+ if _, err := r.Read(v[0:1]); 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
+}
--- /dev/null
+/*
+ * 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"
+ "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))
+ }
+ }
+}
} else if err != nil {
return err
}
- if !ok || !inputProtocol.Transport().Peek() {
+ if !ok {
break
}
}
// Returns true if the transport is open
IsOpen() bool
+}
+
+type stringWriter interface {
+ WriteString(s string) (n int, err error)
+}
- // Returns true if there is more data to be read or the remote side is still open
- Peek() bool
+// 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
}
Code Review / common / thrift.git / commitdiff
