github.com/ronaksoft/rony@v0.16.26-0.20230807065236-1743dbfe6959/example/echo/rpc/sample.rony.go

// Code generated by Rony's protoc plugin; DO NOT EDIT.
// ProtoC ver. v3.17.3
// Rony ver. v0.16.24
// Source: sample.proto

package service

import (
	bytes "bytes"
	context "context"
	fmt "fmt"
	rony "github.com/ronaksoft/rony"
	config "github.com/ronaksoft/rony/config"
	edge "github.com/ronaksoft/rony/edge"
	edgec "github.com/ronaksoft/rony/edgec"
	errors "github.com/ronaksoft/rony/errors"
	pools "github.com/ronaksoft/rony/pools"
	registry "github.com/ronaksoft/rony/registry"
	tools "github.com/ronaksoft/rony/tools"
	cobra "github.com/spf13/cobra"
	protojson "google.golang.org/protobuf/encoding/protojson"
	proto "google.golang.org/protobuf/proto"
	http "net/http"
	sync "sync"
)

var _ = pools.Imported

const C_EchoRequest uint64 = 634453994073422796

type poolEchoRequest struct {
	pool sync.Pool
}

func (p *poolEchoRequest) Get() *EchoRequest {
	x, ok := p.pool.Get().(*EchoRequest)
	if !ok {
		x = &EchoRequest{}
	}

	return x
}

func (p *poolEchoRequest) Put(x *EchoRequest) {
	if x == nil {
		return
	}

	x.ID = 0
	x.RandomText = ""

	p.pool.Put(x)
}

var PoolEchoRequest = poolEchoRequest{}

func (x *EchoRequest) DeepCopy(z *EchoRequest) {
	z.ID = x.ID
	z.RandomText = x.RandomText
}

func (x *EchoRequest) Clone() *EchoRequest {
	z := &EchoRequest{}
	x.DeepCopy(z)
	return z
}

func (x *EchoRequest) Unmarshal(b []byte) error {
	return proto.UnmarshalOptions{Merge: true}.Unmarshal(b, x)
}

func (x *EchoRequest) Marshal() ([]byte, error) {
	return proto.Marshal(x)
}

func (x *EchoRequest) UnmarshalJSON(b []byte) error {
	return protojson.Unmarshal(b, x)
}

func (x *EchoRequest) MarshalJSON() ([]byte, error) {
	return protojson.Marshal(x)
}

func factoryEchoRequest() registry.Message {
	return &EchoRequest{}
}

func (x *EchoRequest) PushToContext(ctx *edge.RequestCtx) {
	ctx.PushMessage(C_EchoRequest, x)
}

const C_EchoResponse uint64 = 10208763112635265787

type poolEchoResponse struct {
	pool sync.Pool
}

func (p *poolEchoResponse) Get() *EchoResponse {
	x, ok := p.pool.Get().(*EchoResponse)
	if !ok {
		x = &EchoResponse{}
	}

	return x
}

func (p *poolEchoResponse) Put(x *EchoResponse) {
	if x == nil {
		return
	}

	x.ReqID = 0
	x.RandomText = ""

	p.pool.Put(x)
}

var PoolEchoResponse = poolEchoResponse{}

func (x *EchoResponse) DeepCopy(z *EchoResponse) {
	z.ReqID = x.ReqID
	z.RandomText = x.RandomText
}

func (x *EchoResponse) Clone() *EchoResponse {
	z := &EchoResponse{}
	x.DeepCopy(z)
	return z
}

func (x *EchoResponse) Unmarshal(b []byte) error {
	return proto.UnmarshalOptions{Merge: true}.Unmarshal(b, x)
}

func (x *EchoResponse) Marshal() ([]byte, error) {
	return proto.Marshal(x)
}

func (x *EchoResponse) UnmarshalJSON(b []byte) error {
	return protojson.Unmarshal(b, x)
}

func (x *EchoResponse) MarshalJSON() ([]byte, error) {
	return protojson.Marshal(x)
}

func factoryEchoResponse() registry.Message {
	return &EchoResponse{}
}

func (x *EchoResponse) PushToContext(ctx *edge.RequestCtx) {
	ctx.PushMessage(C_EchoResponse, x)
}

const C_SampleEcho uint64 = 5610266072904040111

// register constructors of the messages to the registry package
func init() {
	registry.Register(634453994073422796, "EchoRequest", factoryEchoRequest)
	registry.Register(10208763112635265787, "EchoResponse", factoryEchoResponse)
	registry.Register(5610266072904040111, "SampleEcho", factoryEchoRequest)

}

var _ = tools.TimeUnix()

type ISample interface {
	Echo(ctx *edge.RequestCtx, req *EchoRequest, res *EchoResponse) *rony.Error
}

func RegisterSample(h ISample, e *edge.Server, preHandlers ...edge.Handler) {
	w := sampleWrapper{
		h: h,
	}
	w.Register(e, func(c uint64) []edge.Handler {
		return preHandlers
	})
}

func RegisterSampleWithFunc(h ISample, e *edge.Server, handlerFunc func(c uint64) []edge.Handler) {
	w := sampleWrapper{
		h: h,
	}
	w.Register(e, handlerFunc)
}

type sampleWrapper struct {
	h ISample
}

func (sw *sampleWrapper) echoWrapper(ctx *edge.RequestCtx, in *rony.MessageEnvelope) {
	req := &EchoRequest{}
	res := &EchoResponse{}

	var err error
	if in.JsonEncoded {
		err = protojson.Unmarshal(in.Message, req)
	} else {
		err = proto.UnmarshalOptions{Merge: true}.Unmarshal(in.Message, req)
	}
	if err != nil {
		ctx.PushError(errors.ErrInvalidRequest)
		return
	}

	rErr := sw.h.Echo(ctx, req, res)
	if rErr != nil {
		ctx.PushError(rErr)
		return
	}
	if !ctx.Stopped() {
		ctx.PushMessage(C_EchoResponse, res)
	}
}

func (sw *sampleWrapper) Register(e *edge.Server, handlerFunc func(c uint64) []edge.Handler) {
	if handlerFunc == nil {
		handlerFunc = func(c uint64) []edge.Handler {
			return nil
		}
	}
	e.SetHandler(
		edge.NewHandlerOptions().
			SetConstructor(C_SampleEcho).
			SetServiceName("Sample").
			SetMethodName("Echo").
			SetHandler(handlerFunc(C_SampleEcho)...).
			Append(sw.echoWrapper),
	)
	e.SetRestProxy(
		"get", "/echo/:ID/:Random",
		edge.NewRestProxy(sw.echoRestClient, sw.echoRestServer),
	)
}

func TunnelRequestSampleEcho(
	ctx *edge.RequestCtx, replicaSet uint64,
	req *EchoRequest, res *EchoResponse,
	kvs ...*rony.KeyValue,
) error {
	out := rony.PoolMessageEnvelope.Get()
	defer rony.PoolMessageEnvelope.Put(out)
	in := rony.PoolMessageEnvelope.Get()
	defer rony.PoolMessageEnvelope.Put(in)
	out.Fill(ctx.ReqID(), C_SampleEcho, req, kvs...)
	err := ctx.TunnelRequest(replicaSet, out, in)
	if err != nil {
		return err
	}

	switch in.GetConstructor() {
	case C_EchoResponse:
		_ = res.Unmarshal(in.GetMessage())
		return nil
	case rony.C_Error:
		x := &rony.Error{}
		_ = x.Unmarshal(in.GetMessage())
		return x
	default:
		return errors.ErrUnexpectedTunnelResponse
	}
}

func (sw *sampleWrapper) echoRestClient(conn rony.RestConn, ctx *edge.DispatchCtx) error {
	req := &EchoRequest{}
	req.ID = tools.StrToInt64(tools.GetString(conn.Get("ID"), "0"))
	req.RandomText = tools.GetString(conn.Get("Random"), "")

	ctx.Fill(conn.ConnID(), C_SampleEcho, req)
	return nil
}
func (sw *sampleWrapper) echoRestServer(conn rony.RestConn, ctx *edge.DispatchCtx) (err error) {
	conn.WriteHeader("Content-Type", "application/json")
	if !ctx.BufferPop(func(envelope *rony.MessageEnvelope) {
		switch envelope.Constructor {
		case C_EchoResponse:
			x := &EchoResponse{}
			_ = x.Unmarshal(envelope.Message)
			var b []byte
			b, err = x.MarshalJSON()
			if err != nil {
				return
			}
			err = conn.WriteBinary(ctx.StreamID(), b)
			return
		case rony.C_Error:
			x := &rony.Error{}
			_ = x.Unmarshal(envelope.Message)
			err = x
			return
		case rony.C_Redirect:
			x := &rony.Redirect{}
			_ = x.Unmarshal(envelope.Message)
			if len(x.Edges) == 0 || len(x.Edges[0].HostPorts) == 0 {
				break
			}
			switch x.Reason {
			case rony.RedirectReason_ReplicaSetSession:
				conn.Redirect(http.StatusPermanentRedirect, x.Edges[0].HostPorts[0])
			case rony.RedirectReason_ReplicaSetRequest:
				conn.Redirect(http.StatusTemporaryRedirect, x.Edges[0].HostPorts[0])
			}
			return
		}
		err = errors.ErrUnexpectedResponse
	}) {
		err = errors.ErrInternalServer
	}

	return
}

type ISampleClient interface {
	Echo(ctx context.Context, req *EchoRequest, kvs ...*rony.KeyValue) (*EchoResponse, error)
}

type SampleClient struct {
	name string
	c    edgec.Client
}

func NewSampleClient(name string, ec edgec.Client) *SampleClient {
	return &SampleClient{
		name: name,
		c:    ec,
	}
}
func (c *SampleClient) Echo(
	ctx context.Context, req *EchoRequest, kvs ...*rony.KeyValue,
) (*EchoResponse, error) {
	out := rony.PoolMessageEnvelope.Get()
	defer rony.PoolMessageEnvelope.Put(out)
	in := rony.PoolMessageEnvelope.Get()
	defer rony.PoolMessageEnvelope.Put(in)
	out.Fill(c.c.GetRequestID(), C_SampleEcho, req, kvs...)
	err := c.c.Send(ctx, out, in)
	if err != nil {
		return nil, err
	}
	switch in.GetConstructor() {
	case C_EchoResponse:
		x := &EchoResponse{}
		_ = proto.Unmarshal(in.Message, x)
		return x, nil
	case rony.C_Error:
		x := &rony.Error{}
		_ = x.Unmarshal(in.Message)
		return nil, x
	default:
		return nil, fmt.Errorf("unknown message :%d", in.GetConstructor())
	}
}

func prepareSampleCommand(cmd *cobra.Command, c edgec.Client) (*SampleClient, error) {
	// Bind current flags to the registered flags in config package
	err := config.BindCmdFlags(cmd)
	if err != nil {
		return nil, err
	}

	return NewSampleClient("Sample", c), nil
}

var genSampleEchoCmd = func(h ISampleCli, c edgec.Client) *cobra.Command {
	cmd := &cobra.Command{
		Use: "echo",
		RunE: func(cmd *cobra.Command, args []string) error {
			cli, err := prepareSampleCommand(cmd, c)
			if err != nil {
				return err
			}
			return h.Echo(cli, cmd, args)
		},
	}
	config.SetFlags(cmd,
		config.Int64Flag("id", tools.StrToInt64(""), ""),
		config.StringFlag("randomText", "", ""),
	)
	return cmd
}

type ISampleCli interface {
	Echo(cli *SampleClient, cmd *cobra.Command, args []string) error
}

func RegisterSampleCli(h ISampleCli, c edgec.Client, rootCmd *cobra.Command) {
	subCommand := &cobra.Command{
		Use: "Sample",
	}
	subCommand.AddCommand(
		genSampleEchoCmd(h, c),
	)

	rootCmd.AddCommand(subCommand)
}

var _ = bytes.MinRead