ping

package
v0.9.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Feb 2, 2021 License: MIT Imports: 9 Imported by: 0

Documentation

Overview

Package ping is generated code used to make or handle TChannel calls using Thrift.

Index

Constants

This section is empty.

Variables

View Source
var GoUnusedProtection__ int
View Source
var Pong_Pheader_DEFAULT string

Functions

func NewTChanPingPongServiceInheritedClient

func NewTChanPingPongServiceInheritedClient(thriftService string, client thrift.TChanClient) *tchanPingPongServiceClient

func NewTChanPingPongServiceServer

func NewTChanPingPongServiceServer(handler TChanPingPongService) thrift.TChanServer

NewTChanPingPongServiceServer wraps a handler for TChanPingPongService so it can be registered with a thrift.Server.

Types

type Ping

type Ping struct {
	Key string `thrift:"key,1,required" json:"key"`
}

Attributes:

  • Key
var PingPongServicePingArgs_Request_DEFAULT *Ping

func NewPing

func NewPing() *Ping

func (*Ping) GetKey

func (p *Ping) GetKey() string

func (*Ping) Read

func (p *Ping) Read(iprot thrift.TProtocol) error

func (*Ping) String

func (p *Ping) String() string

func (*Ping) Write

func (p *Ping) Write(oprot thrift.TProtocol) error

type PingPongService

type PingPongService interface {
	// Parameters:
	//  - Request
	Ping(request *Ping) (r *Pong, err error)
}

type PingPongServiceClient

type PingPongServiceClient struct {
	Transport       thrift.TTransport
	ProtocolFactory thrift.TProtocolFactory
	InputProtocol   thrift.TProtocol
	OutputProtocol  thrift.TProtocol
	SeqId           int32
}

func NewPingPongServiceClientProtocol

func NewPingPongServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *PingPongServiceClient

func (*PingPongServiceClient) Ping

func (p *PingPongServiceClient) Ping(request *Ping) (r *Pong, err error)

Parameters:

  • Request

type PingPongServiceConfiguration

type PingPongServiceConfiguration struct {
	// Ping holds the forwarding configuration for the Ping endpoint defined in the service
	Ping *PingPongServicePingConfiguration
}

PingPongServiceConfiguration contains the forwarding configuration for the PingPongService service. It has a field for every endpoint defined in the service. In this field the endpoint specific forward configuration can be stored. Populating these fields is optional, default behaviour is to call the service implementation locally to the process where the call came in.

type PingPongServicePingArgs

type PingPongServicePingArgs struct {
	Request *Ping `thrift:"request,1" json:"request"`
}

Attributes:

  • Request

func NewPingPongServicePingArgs

func NewPingPongServicePingArgs() *PingPongServicePingArgs

func (*PingPongServicePingArgs) GetRequest

func (p *PingPongServicePingArgs) GetRequest() *Ping

func (*PingPongServicePingArgs) IsSetRequest

func (p *PingPongServicePingArgs) IsSetRequest() bool

func (*PingPongServicePingArgs) Read

func (*PingPongServicePingArgs) String

func (p *PingPongServicePingArgs) String() string

func (*PingPongServicePingArgs) Write

type PingPongServicePingConfiguration

type PingPongServicePingConfiguration struct {
	// Key is a closure that generates a routable key based on the parameters of the incomming request.
	Key func(ctx thrift.Context, request *Ping) (string, error)
}

PingPongServicePingConfiguration contains the configuration on how to route calls to the thrift endpoint PingPongService::Ping.

type PingPongServicePingResult

type PingPongServicePingResult struct {
	Success *Pong `thrift:"success,0" json:"success,omitempty"`
}

Attributes:

  • Success

func NewPingPongServicePingResult

func NewPingPongServicePingResult() *PingPongServicePingResult

func (*PingPongServicePingResult) GetSuccess

func (p *PingPongServicePingResult) GetSuccess() *Pong

func (*PingPongServicePingResult) IsSetSuccess

func (p *PingPongServicePingResult) IsSetSuccess() bool

func (*PingPongServicePingResult) Read

func (*PingPongServicePingResult) String

func (p *PingPongServicePingResult) String() string

func (*PingPongServicePingResult) Write

type PingPongServiceProcessor

type PingPongServiceProcessor struct {
	// contains filtered or unexported fields
}

func NewPingPongServiceProcessor

func NewPingPongServiceProcessor(handler PingPongService) *PingPongServiceProcessor

func (*PingPongServiceProcessor) AddToProcessorMap

func (p *PingPongServiceProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction)

func (*PingPongServiceProcessor) GetProcessorFunction

func (p *PingPongServiceProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool)

func (*PingPongServiceProcessor) Process

func (p *PingPongServiceProcessor) Process(iprot, oprot thrift.TProtocol) (success bool, err thrift.TException)

func (*PingPongServiceProcessor) ProcessorMap

type Pong

type Pong struct {
	Message string  `thrift:"message,1,required" json:"message"`
	From_   string  `thrift:"from_,2,required" json:"from_"`
	Pheader *string `thrift:"pheader,3" json:"pheader,omitempty"`
}

Attributes:

  • Message
  • From_
  • Pheader
var PingPongServicePingResult_Success_DEFAULT *Pong

func NewPong

func NewPong() *Pong

func (*Pong) GetFrom_

func (p *Pong) GetFrom_() string

func (*Pong) GetMessage

func (p *Pong) GetMessage() string

func (*Pong) GetPheader

func (p *Pong) GetPheader() string

func (*Pong) IsSetPheader

func (p *Pong) IsSetPheader() bool

func (*Pong) Read

func (p *Pong) Read(iprot thrift.TProtocol) error

func (*Pong) String

func (p *Pong) String() string

func (*Pong) Write

func (p *Pong) Write(oprot thrift.TProtocol) error

type RingpopPingPongServiceAdapter

type RingpopPingPongServiceAdapter struct {
	// contains filtered or unexported fields
}

func (*RingpopPingPongServiceAdapter) GetLocalClient

func (a *RingpopPingPongServiceAdapter) GetLocalClient() interface{}

GetLocalClient satisfies the ClientFactory interface of ringpop-go/router

func (*RingpopPingPongServiceAdapter) MakeRemoteClient

func (a *RingpopPingPongServiceAdapter) MakeRemoteClient(client thrift.TChanClient) interface{}

MakeRemoteClient satisfies the ClientFactory interface of ringpop-go/router

func (*RingpopPingPongServiceAdapter) Ping

func (a *RingpopPingPongServiceAdapter) Ping(ctx thrift.Context, request *Ping) (r *Pong, err error)

Ping satisfies the TChanPingPongService interface. This function uses the configuration for Ping to determine the host to execute the call on. When it decides the call needs to be executed in the current process it will forward the invocation to its local implementation.

type TChanPingPongService

type TChanPingPongService interface {
	Ping(ctx thrift.Context, request *Ping) (*Pong, error)
}

TChanPingPongService is the interface that defines the server handler and client interface.

func NewRingpopPingPongServiceAdapter

func NewRingpopPingPongServiceAdapter(
	impl TChanPingPongService,
	rp ringpop.Interface,
	ch *tchannel.Channel,
	config PingPongServiceConfiguration,
) (TChanPingPongService, error)

NewRingpopPingPongServiceAdapter creates an implementation of the TChanPingPongService interface. This specific implementation will use to configuration provided during construction to deterministically route calls to nodes from a ringpop cluster. The channel should be the channel on which the service exposes its endpoints. Forwarded calls, calls to unconfigured endpoints and calls that already were executed on the right machine will be passed on the the implementation passed in during construction.

Example usage:

import "github.com/uber/tchannel-go/thrift"

var server thrift.Server
server = ...

var handler TChanPingPongService
handler = &YourImplementation{}

adapter, _ := NewRingpopPingPongServiceAdapter(handler, ringpop, channel,
  PingPongServiceConfiguration{
    Ping: &PingPongServicePingConfiguration: {
      Key: func(ctx thrift.Context, request *Ping) (shardKey string, err error) {
        return "calculated-shard-key", nil
      },
    },
  },
)
server.Register(NewTChanPingPongServiceServer(adapter))

func NewTChanPingPongServiceClient

func NewTChanPingPongServiceClient(client thrift.TChanClient) TChanPingPongService

NewTChanPingPongServiceClient creates a client that can be used to make remote calls.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL