Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

rpc

package

Go to main page

Versions in this module

v0

v0.8.0

Nov 13, 2024

Changes in this version

+ const EnvAmRpcLogClient

+ const EnvAmRpcLogMux

+ const EnvAmRpcLogServer

+ var ErrNoAccess = errors.New("no access")

+ var ErrNoConn = errors.New("not connected")

+ func AddErr(mach *am.Machine, msg string, err error)

+ func AddErrNetwork(mach *am.Machine, err error)

+ func AddErrNoConn(mach *am.Machine, err error)

+ func AddErrParams(mach *am.Machine, err error)

+ func AddErrResp(mach *am.Machine, err error)

+ func AddErrRpcStr(mach *am.Machine, msg string)

+ func BindServer(source, target *am.Machine, rpcReady, clientConn string) error

+ func BindServerMulti(source, target *am.Machine, rpcReady, clientConn, clientDisconn string) error

+ func BindServerRpcReady(source, target *am.Machine, rpcReady string) error

+ func GetClientId(name string) string

+ func LogArgs(args am.A) map[string]string

+ func Pass(args *A) am.A

+ type A struct

+ Addr string

+ Client *rpc2.Client

+ Dispose bool

+ Err error

+ Id string

+ MachTime am.Time

+ Method string

+ Name string

+ Payload *ArgsPayload

+ StartedAt time.Time

+ func ParseArgs(args am.A) *A

type ArgsPayload

+ Source string

+ Token string

type Client

+ Addr string

+ CallRetries int

+ CallRetryBackoff time.Duration

+ CallRetryDelay time.Duration

+ CallRetryTimeout time.Duration

+ ConnRetries int

+ ConnRetryBackoff time.Duration

+ ConnRetryDelay time.Duration

+ ConnRetryTimeout time.Duration

+ ConnTimeout time.Duration

+ Consumer *am.Machine

+ DisconnCooldown time.Duration

+ HelloDelay time.Duration

+ LastMsgAt time.Time

+ Name string

+ ReconnectOn bool

+ func (c *Client) CallRetryFailedState(e *am.Event)

+ func (c *Client) ExceptionState(e *am.Event)

+ func (c *Client) HandshakeDoneEnter(e *am.Event) bool

+ func (c *Client) RemotePushAllTicks(_ *rpc2.Client, clocks []PushAllTicks, _ *Empty) error

+ func (c *Client) RemoteSendingPayload(_ *rpc2.Client, payload *ArgsPayload, _ *Empty) error

+ func (c *Client) RetryingCallEnter(e *am.Event) bool

+ func (c *Client) RetryingConnState(e *am.Event)

+ func (c *Client) StartState(e *am.Event)

+ func (c *Client) WorkerPayloadEnter(e *am.Event) bool

+ func (c *Client) WorkerPayloadState(e *am.Event)

+ type ClientOpts struct

+ Consumer *am.Machine

+ Parent am.Api

+ type Event struct

+ Machine am.Api

+ Name string

+ type HandlerFinal func(e *Event)

+ type Mux struct

+ Addr string

+ Listener net.Listener

+ LogEnabled bool

+ Mach *am.Machine

+ Name string

+ NewServerErr error

+ NewServerFn MuxNewServer

+ func NewMux(ctx context.Context, name string, newServer MuxNewServer, opts *MuxOpts) (*Mux, error)

+ func (m *Mux) ClientConnectedState(e *am.Event)

+ func (m *Mux) ExceptionState(e *am.Event)

+ func (m *Mux) HasClientsEnd(e *am.Event) bool

+ func (m *Mux) HealthcheckState(e *am.Event)

+ func (m *Mux) NewServerErrEnter(e *am.Event) bool

+ func (m *Mux) NewServerErrState(e *am.Event)

+ func (m *Mux) Start() am.Result

+ func (m *Mux) StartEnd(e *am.Event)

+ func (m *Mux) StartState(e *am.Event)

+ func (m *Mux) Stop(dispose bool) am.Result

+ type MuxNewServer func(num int, conn net.Conn) (*Server, error)

+ type MuxOpts struct

+ Parent am.Api

+ type PushAllTicks struct

+ ClockMsg ClockMsg

+ Mutation []int

+ type SendPayloadHandlers struct

+ SendPayloadState am.HandlerFinal

type Server

+ AllowId string

+ Conn net.Conn

+ DeliveryTimeout time.Duration

+ NoNewListener bool

+ PushAllTicks bool

+ PushInterval time.Duration

+ func (s *Server) RemoteHello(client *rpc2.Client, _ *Empty, resp *RespHandshake) error

+ func (s *Server) RemoteSetPushAllTicks(_ *rpc2.Client, val bool, _ *Empty) error

+ func (s *Server) RpcReadyEnter(e *am.Event) bool

+ func (s *Server) RpcStartingEnter(e *am.Event) bool

+ func (s *Server) StartEnd(e *am.Event)

+ type ServerOpts struct

+ Parent am.Api

+ PayloadState string

+ type Transition struct

+ Machine am.Api

+ TimeAfter am.Time

+ TimeBefore am.Time

type Worker

+ func (w *Worker) BindHandlers(handlers any) error

+ func (w *Worker) BindTracer(tracer am.Tracer)

+ func (w *Worker) DetachTracer(tracer am.Tracer) bool

+ func (w *Worker) GetLogId() bool

+ func (w *Worker) GetLogLevel() am.LogLevel

+ func (w *Worker) GetLogger() *am.Logger

+ func (w *Worker) Id() string

+ func (w *Worker) IsDisposed() bool

+ func (w *Worker) LogLvl(lvl am.LogLevel, msg string, args ...any)

+ func (w *Worker) ParentId() string

+ func (w *Worker) SetLogId(val bool)

+ func (w *Worker) SetLogLevel(level am.LogLevel)

+ func (w *Worker) SetLogger(fn am.Logger)

+ func (w *Worker) SetLoggerEmpty(level am.LogLevel)

+ func (w *Worker) SetLoggerSimple(logf func(format string, args ...any), level am.LogLevel)

+ func (w *Worker) StatesVerified() bool

+ func (w *Worker) Tracers() []am.Tracer

v0.8.0-pre

Nov 13, 2024

v0.7.1

Nov 13, 2024

v0.7.0

Sep 14, 2024

Changes in this version

+ var ErrInvalidParams = errors.New("invalid params")

+ var ErrInvalidResp = errors.New("invalid response")

+ var ErrNetwork = errors.New("network error")

+ var ErrNetworkTimeout = errors.New("network timeout")

+ var ErrRpc = errors.New("rpc")

+ func ClockFromMsg(before am.Time, msg ClockMsg) am.Time

+ func TrafficMeter(listener net.Listener, fwdTo string, counter chan<- int64, end <-chan struct{})

+ type ArgsGet struct

+ Name string

+ type ArgsLog struct

+ Args []any

+ Msg string

+ type ArgsMut struct

+ Args am.A

+ States []int

+ type ArgsPayload struct

+ Data []byte

+ Name string

+ type Client struct

+ CallCount uint64

+ CallTimeout time.Duration

+ LogEnabled bool

+ Mach *am.Machine

+ Payloads map[string]*ArgsPayload

+ Worker *Worker

+ func NewClient(ctx context.Context, workerAddr string, id string, stateStruct am.Struct, ...) (*Client, error)

+ func (c *Client) ConnectedState(e *am.Event)

+ func (c *Client) ConnectingState(e *am.Event)

+ func (c *Client) DisconnectedEnter(e *am.Event) bool

+ func (c *Client) DisconnectedState(e *am.Event)

+ func (c *Client) DisconnectingEnter(e *am.Event) bool

+ func (c *Client) DisconnectingState(e *am.Event)

+ func (c *Client) Get(ctx context.Context, name string) (*RespGet, error)

+ func (c *Client) GetKind() Kind

+ func (c *Client) HandshakeDoneState(e *am.Event)

+ func (c *Client) HandshakingState(e *am.Event)

+ func (c *Client) RemoteSendPayload(_ *rpc2.Client, file *ArgsPayload, _ *Empty) error

+ func (c *Client) RemoteSetClock(_ *rpc2.Client, clock ClockMsg, _ *Empty) error

+ func (c *Client) Start() am.Result

+ func (c *Client) StartEnd(e *am.Event)

+ func (c *Client) Stop(waitTillExit context.Context, dispose bool) am.Result

+ type ClockMsg [][2]int

+ func NewClockMsg(before, after am.Time) ClockMsg

+ type Empty struct

+ type ExceptionHandler struct

+ func (h *ExceptionHandler) ExceptionEnter(e *am.Event) bool

+ func (h *ExceptionHandler) ExceptionState(e *am.Event)

+ type GetterFunc func(string) any

+ type Kind string

+ const KindClient

+ const KindServer

+ type RespGet struct

+ Value any

+ type RespHandshake = am.Serialized

+ type RespResult struct

+ Clock ClockMsg

+ Result am.Result

+ type RespSync struct

+ Time am.Time

+ type Server struct

+ Addr string

+ CallCount uint64

+ ClockInterval time.Duration

+ Listener net.Listener

+ LogEnabled bool

+ Mach *am.Machine

+ func NewServer(ctx context.Context, addr string, id string, worker *am.Machine, ...) (*Server, error)

+ func (s *Server) GetKind() Kind

+ func (s *Server) HandshakeDoneEnd(e *am.Event)

+ func (s *Server) RemoteAdd(_ *rpc2.Client, args *ArgsMut, resp *RespResult) error

+ func (s *Server) RemoteAddNS(_ *rpc2.Client, args *ArgsMut, _ *Empty) error

+ func (s *Server) RemoteBye(_ *rpc2.Client, _ *Empty, _ *Empty) error

+ func (s *Server) RemoteGet(_ *rpc2.Client, name string, resp *RespGet) error

+ func (s *Server) RemoteHandshake(client *rpc2.Client, _ *Empty, resp *RespHandshake) error

+ func (s *Server) RemoteHandshakeAck(client *rpc2.Client, done *bool, _ *Empty) error

+ func (s *Server) RemoteRemove(_ *rpc2.Client, args *ArgsMut, resp *RespResult) error

+ func (s *Server) RemoteSet(_ *rpc2.Client, args *ArgsMut, resp *RespResult) error

+ func (s *Server) RemoteSync(_ *rpc2.Client, sum uint64, resp *RespSync) error

+ func (s *Server) RpcReadyEnd(e *am.Event)

+ func (s *Server) RpcReadyState(e *am.Event)

+ func (s *Server) RpcStartingState(e *am.Event)

+ func (s *Server) SendPayload(ctx context.Context, file *ArgsPayload) error

+ func (s *Server) Start() am.Result

+ func (s *Server) Stop(dispose bool) am.Result

+ type Worker struct

+ Ctx context.Context

+ Disposed atomic.Bool

+ ID string

+ func (w *Worker) ActiveStates() am.S

+ func (w *Worker) Add(states am.S, args am.A) am.Result

+ func (w *Worker) Add1(state string, args am.A) am.Result

+ func (w *Worker) Add1NS(state string, args am.A) am.Result

+ func (w *Worker) AddErr(err error, args am.A) am.Result

+ func (w *Worker) AddErrState(state string, err error, args am.A) am.Result

+ func (w *Worker) AddNS(states am.S, args am.A) am.Result

+ func (w *Worker) Any(states ...am.S) bool

+ func (w *Worker) Any1(states ...string) bool

+ func (w *Worker) Clock(states am.S) am.Clock

+ func (w *Worker) Dispose()

+ func (w *Worker) Err() error

+ func (w *Worker) Export() *am.Serialized

+ func (w *Worker) GetStruct() am.Struct

+ func (w *Worker) Has(states am.S) bool

+ func (w *Worker) Has1(state string) bool

+ func (w *Worker) Index(state string) int

+ func (w *Worker) Inspect(states am.S) string

+ func (w *Worker) Is(states am.S) bool

+ func (w *Worker) Is1(state string) bool

+ func (w *Worker) IsClock(clock am.Clock) bool

+ func (w *Worker) IsErr() bool

+ func (w *Worker) IsTime(t am.Time, states am.S) bool

+ func (w *Worker) Log(msg string, args ...any)

+ func (w *Worker) MustParseStates(states am.S) am.S

+ func (w *Worker) NewStateCtx(state string) context.Context

+ func (w *Worker) Not(states am.S) bool

+ func (w *Worker) Not1(state string) bool

+ func (w *Worker) Remove(states am.S, args am.A) am.Result

+ func (w *Worker) Remove1(state string, args am.A) am.Result

+ func (w *Worker) Set(states am.S, args am.A) am.Result

+ func (w *Worker) StateNames() am.S

+ func (w *Worker) String() string

+ func (w *Worker) StringAll() string

+ func (w *Worker) Switch(states ...string) string

+ func (w *Worker) Sync() am.Time

+ func (w *Worker) Tick(state string) uint64

+ func (w *Worker) Time(states am.S) am.Time

+ func (w *Worker) TimeSum(states am.S) uint64

+ func (w *Worker) When(states am.S, ctx context.Context) <-chan struct{}

+ func (w *Worker) When1(state string, ctx context.Context) <-chan struct{}

+ func (w *Worker) WhenArgs(state string, args am.A, ctx context.Context) <-chan struct{}

+ func (w *Worker) WhenDisposed() <-chan struct{}

+ func (w *Worker) WhenErr(ctx context.Context) <-chan struct{}

+ func (w *Worker) WhenNot(states am.S, ctx context.Context) <-chan struct{}

+ func (w *Worker) WhenNot1(state string, ctx context.Context) <-chan struct{}

+ func (w *Worker) WhenTicks(state string, ticks int, ctx context.Context) <-chan struct{}

+ func (w *Worker) WhenTicksEq(state string, ticks uint64, ctx context.Context) <-chan struct{}

+ func (w *Worker) WhenTime(states am.S, times am.Time, ctx context.Context) <-chan struct{}

+ type WorkerTracer struct

+ func (t *WorkerTracer) TransitionEnd(_ *am.Transition)

v0.7.0-pre1

Sep 11, 2024