ceph/src/jaegertracing/thrift/lib/go/thrift/debug_protocol.go

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one
   3  * or more contributor license agreements. See the NOTICE file
   4  * distributed with this work for additional information
   5  * regarding copyright ownership. The ASF licenses this file
   6  * to you under the Apache License, Version 2.0 (the
   7  * "License"); you may not use this file except in compliance
   8  * with the License. You may obtain a copy of the License at
   9  *
  10  *   http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing,
  13  * software distributed under the License is distributed on an
  14  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  15  * KIND, either express or implied. See the License for the
  16  * specific language governing permissions and limitations
  17  * under the License.
  18  */
  19
  20 package thrift
  21
  22 import (
  23         "context"
  24         "log"
  25 )
  26
  27 type TDebugProtocol struct {
  28         Delegate  TProtocol
  29         LogPrefix string
  30 }
  31
  32 type TDebugProtocolFactory struct {
  33         Underlying TProtocolFactory
  34         LogPrefix  string
  35 }
  36
  37 func NewTDebugProtocolFactory(underlying TProtocolFactory, logPrefix string) *TDebugProtocolFactory {
  38         return &TDebugProtocolFactory{
  39                 Underlying: underlying,
  40                 LogPrefix:  logPrefix,
  41         }
  42 }
  43
  44 func (t *TDebugProtocolFactory) GetProtocol(trans TTransport) TProtocol {
  45         return &TDebugProtocol{
  46                 Delegate:  t.Underlying.GetProtocol(trans),
  47                 LogPrefix: t.LogPrefix,
  48         }
  49 }
  50
  51 func (tdp *TDebugProtocol) WriteMessageBegin(name string, typeId TMessageType, seqid int32) error {
  52         err := tdp.Delegate.WriteMessageBegin(name, typeId, seqid)
  53         log.Printf("%sWriteMessageBegin(name=%#v, typeId=%#v, seqid=%#v) => %#v", tdp.LogPrefix, name, typeId, seqid, err)
  54         return err
  55 }
  56 func (tdp *TDebugProtocol) WriteMessageEnd() error {
  57         err := tdp.Delegate.WriteMessageEnd()
  58         log.Printf("%sWriteMessageEnd() => %#v", tdp.LogPrefix, err)
  59         return err
  60 }
  61 func (tdp *TDebugProtocol) WriteStructBegin(name string) error {
  62         err := tdp.Delegate.WriteStructBegin(name)
  63         log.Printf("%sWriteStructBegin(name=%#v) => %#v", tdp.LogPrefix, name, err)
  64         return err
  65 }
  66 func (tdp *TDebugProtocol) WriteStructEnd() error {
  67         err := tdp.Delegate.WriteStructEnd()
  68         log.Printf("%sWriteStructEnd() => %#v", tdp.LogPrefix, err)
  69         return err
  70 }
  71 func (tdp *TDebugProtocol) WriteFieldBegin(name string, typeId TType, id int16) error {
  72         err := tdp.Delegate.WriteFieldBegin(name, typeId, id)
  73         log.Printf("%sWriteFieldBegin(name=%#v, typeId=%#v, id%#v) => %#v", tdp.LogPrefix, name, typeId, id, err)
  74         return err
  75 }
  76 func (tdp *TDebugProtocol) WriteFieldEnd() error {
  77         err := tdp.Delegate.WriteFieldEnd()
  78         log.Printf("%sWriteFieldEnd() => %#v", tdp.LogPrefix, err)
  79         return err
  80 }
  81 func (tdp *TDebugProtocol) WriteFieldStop() error {
  82         err := tdp.Delegate.WriteFieldStop()
  83         log.Printf("%sWriteFieldStop() => %#v", tdp.LogPrefix, err)
  84         return err
  85 }
  86 func (tdp *TDebugProtocol) WriteMapBegin(keyType TType, valueType TType, size int) error {
  87         err := tdp.Delegate.WriteMapBegin(keyType, valueType, size)
  88         log.Printf("%sWriteMapBegin(keyType=%#v, valueType=%#v, size=%#v) => %#v", tdp.LogPrefix, keyType, valueType, size, err)
  89         return err
  90 }
  91 func (tdp *TDebugProtocol) WriteMapEnd() error {
  92         err := tdp.Delegate.WriteMapEnd()
  93         log.Printf("%sWriteMapEnd() => %#v", tdp.LogPrefix, err)
  94         return err
  95 }
  96 func (tdp *TDebugProtocol) WriteListBegin(elemType TType, size int) error {
  97         err := tdp.Delegate.WriteListBegin(elemType, size)
  98         log.Printf("%sWriteListBegin(elemType=%#v, size=%#v) => %#v", tdp.LogPrefix, elemType, size, err)
  99         return err
 100 }
 101 func (tdp *TDebugProtocol) WriteListEnd() error {
 102         err := tdp.Delegate.WriteListEnd()
 103         log.Printf("%sWriteListEnd() => %#v", tdp.LogPrefix, err)
 104         return err
 105 }
 106 func (tdp *TDebugProtocol) WriteSetBegin(elemType TType, size int) error {
 107         err := tdp.Delegate.WriteSetBegin(elemType, size)
 108         log.Printf("%sWriteSetBegin(elemType=%#v, size=%#v) => %#v", tdp.LogPrefix, elemType, size, err)
 109         return err
 110 }
 111 func (tdp *TDebugProtocol) WriteSetEnd() error {
 112         err := tdp.Delegate.WriteSetEnd()
 113         log.Printf("%sWriteSetEnd() => %#v", tdp.LogPrefix, err)
 114         return err
 115 }
 116 func (tdp *TDebugProtocol) WriteBool(value bool) error {
 117         err := tdp.Delegate.WriteBool(value)
 118         log.Printf("%sWriteBool(value=%#v) => %#v", tdp.LogPrefix, value, err)
 119         return err
 120 }
 121 func (tdp *TDebugProtocol) WriteByte(value int8) error {
 122         err := tdp.Delegate.WriteByte(value)
 123         log.Printf("%sWriteByte(value=%#v) => %#v", tdp.LogPrefix, value, err)
 124         return err
 125 }
 126 func (tdp *TDebugProtocol) WriteI16(value int16) error {
 127         err := tdp.Delegate.WriteI16(value)
 128         log.Printf("%sWriteI16(value=%#v) => %#v", tdp.LogPrefix, value, err)
 129         return err
 130 }
 131 func (tdp *TDebugProtocol) WriteI32(value int32) error {
 132         err := tdp.Delegate.WriteI32(value)
 133         log.Printf("%sWriteI32(value=%#v) => %#v", tdp.LogPrefix, value, err)
 134         return err
 135 }
 136 func (tdp *TDebugProtocol) WriteI64(value int64) error {
 137         err := tdp.Delegate.WriteI64(value)
 138         log.Printf("%sWriteI64(value=%#v) => %#v", tdp.LogPrefix, value, err)
 139         return err
 140 }
 141 func (tdp *TDebugProtocol) WriteDouble(value float64) error {
 142         err := tdp.Delegate.WriteDouble(value)
 143         log.Printf("%sWriteDouble(value=%#v) => %#v", tdp.LogPrefix, value, err)
 144         return err
 145 }
 146 func (tdp *TDebugProtocol) WriteString(value string) error {
 147         err := tdp.Delegate.WriteString(value)
 148         log.Printf("%sWriteString(value=%#v) => %#v", tdp.LogPrefix, value, err)
 149         return err
 150 }
 151 func (tdp *TDebugProtocol) WriteBinary(value []byte) error {
 152         err := tdp.Delegate.WriteBinary(value)
 153         log.Printf("%sWriteBinary(value=%#v) => %#v", tdp.LogPrefix, value, err)
 154         return err
 155 }
 156
 157 func (tdp *TDebugProtocol) ReadMessageBegin() (name string, typeId TMessageType, seqid int32, err error) {
 158         name, typeId, seqid, err = tdp.Delegate.ReadMessageBegin()
 159         log.Printf("%sReadMessageBegin() (name=%#v, typeId=%#v, seqid=%#v, err=%#v)", tdp.LogPrefix, name, typeId, seqid, err)
 160         return
 161 }
 162 func (tdp *TDebugProtocol) ReadMessageEnd() (err error) {
 163         err = tdp.Delegate.ReadMessageEnd()
 164         log.Printf("%sReadMessageEnd() err=%#v", tdp.LogPrefix, err)
 165         return
 166 }
 167 func (tdp *TDebugProtocol) ReadStructBegin() (name string, err error) {
 168         name, err = tdp.Delegate.ReadStructBegin()
 169         log.Printf("%sReadStructBegin() (name%#v, err=%#v)", tdp.LogPrefix, name, err)
 170         return
 171 }
 172 func (tdp *TDebugProtocol) ReadStructEnd() (err error) {
 173         err = tdp.Delegate.ReadStructEnd()
 174         log.Printf("%sReadStructEnd() err=%#v", tdp.LogPrefix, err)
 175         return
 176 }
 177 func (tdp *TDebugProtocol) ReadFieldBegin() (name string, typeId TType, id int16, err error) {
 178         name, typeId, id, err = tdp.Delegate.ReadFieldBegin()
 179         log.Printf("%sReadFieldBegin() (name=%#v, typeId=%#v, id=%#v, err=%#v)", tdp.LogPrefix, name, typeId, id, err)
 180         return
 181 }
 182 func (tdp *TDebugProtocol) ReadFieldEnd() (err error) {
 183         err = tdp.Delegate.ReadFieldEnd()
 184         log.Printf("%sReadFieldEnd() err=%#v", tdp.LogPrefix, err)
 185         return
 186 }
 187 func (tdp *TDebugProtocol) ReadMapBegin() (keyType TType, valueType TType, size int, err error) {
 188         keyType, valueType, size, err = tdp.Delegate.ReadMapBegin()
 189         log.Printf("%sReadMapBegin() (keyType=%#v, valueType=%#v, size=%#v, err=%#v)", tdp.LogPrefix, keyType, valueType, size, err)
 190         return
 191 }
 192 func (tdp *TDebugProtocol) ReadMapEnd() (err error) {
 193         err = tdp.Delegate.ReadMapEnd()
 194         log.Printf("%sReadMapEnd() err=%#v", tdp.LogPrefix, err)
 195         return
 196 }
 197 func (tdp *TDebugProtocol) ReadListBegin() (elemType TType, size int, err error) {
 198         elemType, size, err = tdp.Delegate.ReadListBegin()
 199         log.Printf("%sReadListBegin() (elemType=%#v, size=%#v, err=%#v)", tdp.LogPrefix, elemType, size, err)
 200         return
 201 }
 202 func (tdp *TDebugProtocol) ReadListEnd() (err error) {
 203         err = tdp.Delegate.ReadListEnd()
 204         log.Printf("%sReadListEnd() err=%#v", tdp.LogPrefix, err)
 205         return
 206 }
 207 func (tdp *TDebugProtocol) ReadSetBegin() (elemType TType, size int, err error) {
 208         elemType, size, err = tdp.Delegate.ReadSetBegin()
 209         log.Printf("%sReadSetBegin() (elemType=%#v, size=%#v, err=%#v)", tdp.LogPrefix, elemType, size, err)
 210         return
 211 }
 212 func (tdp *TDebugProtocol) ReadSetEnd() (err error) {
 213         err = tdp.Delegate.ReadSetEnd()
 214         log.Printf("%sReadSetEnd() err=%#v", tdp.LogPrefix, err)
 215         return
 216 }
 217 func (tdp *TDebugProtocol) ReadBool() (value bool, err error) {
 218         value, err = tdp.Delegate.ReadBool()
 219         log.Printf("%sReadBool() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
 220         return
 221 }
 222 func (tdp *TDebugProtocol) ReadByte() (value int8, err error) {
 223         value, err = tdp.Delegate.ReadByte()
 224         log.Printf("%sReadByte() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
 225         return
 226 }
 227 func (tdp *TDebugProtocol) ReadI16() (value int16, err error) {
 228         value, err = tdp.Delegate.ReadI16()
 229         log.Printf("%sReadI16() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
 230         return
 231 }
 232 func (tdp *TDebugProtocol) ReadI32() (value int32, err error) {
 233         value, err = tdp.Delegate.ReadI32()
 234         log.Printf("%sReadI32() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
 235         return
 236 }
 237 func (tdp *TDebugProtocol) ReadI64() (value int64, err error) {
 238         value, err = tdp.Delegate.ReadI64()
 239         log.Printf("%sReadI64() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
 240         return
 241 }
 242 func (tdp *TDebugProtocol) ReadDouble() (value float64, err error) {
 243         value, err = tdp.Delegate.ReadDouble()
 244         log.Printf("%sReadDouble() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
 245         return
 246 }
 247 func (tdp *TDebugProtocol) ReadString() (value string, err error) {
 248         value, err = tdp.Delegate.ReadString()
 249         log.Printf("%sReadString() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
 250         return
 251 }
 252 func (tdp *TDebugProtocol) ReadBinary() (value []byte, err error) {
 253         value, err = tdp.Delegate.ReadBinary()
 254         log.Printf("%sReadBinary() (value=%#v, err=%#v)", tdp.LogPrefix, value, err)
 255         return
 256 }
 257 func (tdp *TDebugProtocol) Skip(fieldType TType) (err error) {
 258         err = tdp.Delegate.Skip(fieldType)
 259         log.Printf("%sSkip(fieldType=%#v) (err=%#v)", tdp.LogPrefix, fieldType, err)
 260         return
 261 }
 262 func (tdp *TDebugProtocol) Flush(ctx context.Context) (err error) {
 263         err = tdp.Delegate.Flush(ctx)
 264         log.Printf("%sFlush() (err=%#v)", tdp.LogPrefix, err)
 265         return
 266 }
 267
 268 func (tdp *TDebugProtocol) Transport() TTransport {
 269         return tdp.Delegate.Transport()
 270 }