wshutil

package
v0.8.13-beta.3 Latest Latest
Warning

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

 Go to latest Published: Oct 24, 2024 License: Apache-2.0 Imports: 24 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	Mode_Normal  = "normal"
	Mode_Esc     = "esc"
	Mode_WaveEsc = "waveesc"
)
View Source 
const BEL = 0x07
View Source 
const DefaultInputChSize = 32
View Source 
const DefaultMessageChSize = 32
View Source 
const DefaultOutputChSize = 32
View Source 
const DefaultRoute = "wavesrv"
View Source 
const DefaultTimeoutMs = 5000
View Source 
const ESC = 0x1b
View Source 
const ElectronRoute = "electron"
View Source 
const HexChars = "0123456789ABCDEF"
View Source 
const MaxBufferedDataSize = 256 * 1024
View Source 
const RespChSize = 32
View Source 
const ST = 0x9c
View Source 
const SysRoute = "sys" // this route doesn't exist, just a placeholder for system messages
View Source 
const WaveJwtTokenVarName = "WAVETERM_JWT"
View Source 
const WaveOSC = "23198"

these should both be 5 characters

View Source 
const WaveOSCPrefix = "\x1b]" + WaveOSC + ";"
View Source 
const WaveOSCPrefixLen = 5 + 3 // \x1b] + WaveOSC + ; + \x07
View Source 
const WaveServerOSC = "23199"
View Source 
const WaveServerOSCPrefix = "\x1b]" + WaveServerOSC + ";"

Variables

View Source 
var DefaultRouter = NewWshRouter()
View Source 
var WshCommandDeclMap = wshrpc.GenerateWshCommandDeclMap()

Functions

func AdaptMsgChToPty 

func AdaptMsgChToPty(outputCh chan []byte, oscEsc string, output io.Writer) error

func AdaptOutputChToStream 

func AdaptOutputChToStream(outputCh chan []byte, output io.Writer) error

func AdaptStreamToMsgCh 

func AdaptStreamToMsgCh(input io.Reader, output chan []byte) error

func DoShutdown 

func DoShutdown(reason string, exitCode int, quiet bool)

func EncodeWaveOSCBytes 

func EncodeWaveOSCBytes(oscNum string, barr []byte) ([]byte, error)

func EncodeWaveOSCMessageEx 

func EncodeWaveOSCMessageEx(oscNum string, msg *RpcMessage) ([]byte, error)

func ExtractUnverifiedRpcContext 

func ExtractUnverifiedRpcContext(tokenStr string) (*wshrpc.RpcContext, error)

only for use on client

func ExtractUnverifiedSocketName 

func ExtractUnverifiedSocketName(tokenStr string) (string, error)

only for use on client

func GetIsCanceledFromContext 

func GetIsCanceledFromContext(ctx context.Context) bool

func GetRpcSourceFromContext 

func GetRpcSourceFromContext(ctx context.Context) string

func MakeClientJWTToken 

func MakeClientJWTToken(rpcCtx wshrpc.RpcContext, sockName string) (string, error)

func MakeConnectionRouteId 

func MakeConnectionRouteId(connId string) string

func MakeControllerRouteId 

func MakeControllerRouteId(blockId string) string

func MakeProcRouteId 

func MakeProcRouteId(procId string) string

func MakeRouteIdFromCtx 

func MakeRouteIdFromCtx(rpcCtx *wshrpc.RpcContext) (string, error)

func MakeWindowRouteId 

func MakeWindowRouteId(windowId string) string

func RestoreTermState 

func RestoreTermState()

func RunWshRpcOverListener 

func RunWshRpcOverListener(listener net.Listener)

func SetExtraShutdownFunc 

func SetExtraShutdownFunc(fn func())

func SetTermRawMode 

func SetTermRawMode()

func SetTermRawModeAndInstallShutdownHandlers 

func SetTermRawModeAndInstallShutdownHandlers(quietShutdown bool)

func StreamToLines 

func StreamToLines(input io.Reader, lineFn func([]byte)) error

func ValidateAndExtractRpcContextFromToken 

func ValidateAndExtractRpcContextFromToken(tokenStr string) (*wshrpc.RpcContext, error)

Types

type AbstractRpcClient 

type AbstractRpcClient interface {
	SendRpcMessage(msg []byte)
	RecvRpcMessage() ([]byte, bool) // blocking
}

type CommandHandlerFnType 

type CommandHandlerFnType = func(*RpcResponseHandler) bool

returns true if handler is complete, false for an async handler

type EventListener 

type EventListener struct {
	Lock      *sync.Mutex
	Listeners map[string][]singleListener
}

func MakeEventListener 

func MakeEventListener() *EventListener

func (*EventListener) On 

func (el *EventListener) On(eventName string, fn func(*wps.WaveEvent)) string

func (*EventListener) RecvEvent 

func (el *EventListener) RecvEvent(e *wps.WaveEvent)

func (*EventListener) Unregister 

func (el *EventListener) Unregister(eventName string, id string)

type PtyBuffer 

type PtyBuffer struct {
	CVar        *sync.Cond
	DataBuf     *bytes.Buffer
	EscMode     string
	EscSeqBuf   []byte
	OSCPrefix   string
	InputReader io.Reader
	MessageCh   chan []byte
	AtEOF       bool
	Err         error
}

func MakePtyBuffer 

func MakePtyBuffer(oscPrefix string, input io.Reader, messageCh chan []byte) *PtyBuffer

closes messageCh when input is closed (or error)

func (*PtyBuffer) Read 

func (b *PtyBuffer) Read(p []byte) (n int, err error)

type ResponseFnType 

type ResponseFnType = func(any) error

type RpcMessage 

type RpcMessage struct {
	Command  string `json:"command,omitempty"`
	ReqId    string `json:"reqid,omitempty"`
	ResId    string `json:"resid,omitempty"`
	Timeout  int    `json:"timeout,omitempty"`
	Route    string `json:"route,omitempty"`  // to route/forward requests to alternate servers
	Source   string `json:"source,omitempty"` // source route id
	Cont     bool   `json:"cont,omitempty"`   // flag if additional requests/responses are forthcoming
	Cancel   bool   `json:"cancel,omitempty"` // used to cancel a streaming request or response (sent from the side that is not streaming)
	Error    string `json:"error,omitempty"`
	DataType string `json:"datatype,omitempty"`
	Data     any    `json:"data,omitempty"`
}

func (*RpcMessage) IsRpcRequest 

func (r *RpcMessage) IsRpcRequest() bool

func (*RpcMessage) Validate 

func (r *RpcMessage) Validate() error

type RpcRequestHandler 

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

func (*RpcRequestHandler) Context 

func (handler *RpcRequestHandler) Context() context.Context

func (*RpcRequestHandler) NextResponse 

func (handler *RpcRequestHandler) NextResponse() (any, error)

func (*RpcRequestHandler) ResponseDone 

func (handler *RpcRequestHandler) ResponseDone() bool

func (*RpcRequestHandler) SendCancel 

func (handler *RpcRequestHandler) SendCancel()

type RpcResponseHandler 

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

func GetRpcResponseHandlerFromContext 

func GetRpcResponseHandlerFromContext(ctx context.Context) *RpcResponseHandler

func (*RpcResponseHandler) Context 

func (handler *RpcResponseHandler) Context() context.Context

func (*RpcResponseHandler) Finalize 

func (handler *RpcResponseHandler) Finalize()

if async, caller must call finalize

func (*RpcResponseHandler) GetCommand 

func (handler *RpcResponseHandler) GetCommand() string

func (*RpcResponseHandler) GetCommandRawData 

func (handler *RpcResponseHandler) GetCommandRawData() any

func (*RpcResponseHandler) GetRpcContext 

func (handler *RpcResponseHandler) GetRpcContext() wshrpc.RpcContext

func (*RpcResponseHandler) GetSource 

func (handler *RpcResponseHandler) GetSource() string

func (*RpcResponseHandler) IsCanceled 

func (handler *RpcResponseHandler) IsCanceled() bool

func (*RpcResponseHandler) IsDone 

func (handler *RpcResponseHandler) IsDone() bool

func (*RpcResponseHandler) NeedsResponse 

func (handler *RpcResponseHandler) NeedsResponse() bool

func (*RpcResponseHandler) SendMessage 

func (handler *RpcResponseHandler) SendMessage(msg string)

func (*RpcResponseHandler) SendResponse 

func (handler *RpcResponseHandler) SendResponse(data any, done bool) error

func (*RpcResponseHandler) SendResponseError 

func (handler *RpcResponseHandler) SendResponseError(err error)

type ServerImpl 

type ServerImpl interface {
	WshServerImpl()
}

type WshRouter 

type WshRouter struct {
	Lock            *sync.Mutex
	RouteMap        map[string]AbstractRpcClient // routeid => client
	UpstreamClient  AbstractRpcClient            // upstream client (if we are not the terminal router)
	AnnouncedRoutes map[string]string            // routeid => local routeid
	RpcMap          map[string]*routeInfo        // rpcid => routeinfo
	InputCh         chan msgAndRoute
}

func NewWshRouter 

func NewWshRouter() *WshRouter

func (*WshRouter) GetRpc 

func (router *WshRouter) GetRpc(routeId string) AbstractRpcClient

this may return nil (returns default only for empty routeId)

func (*WshRouter) GetUpstreamClient 

func (router *WshRouter) GetUpstreamClient() AbstractRpcClient

func (*WshRouter) RegisterRoute 

func (router *WshRouter) RegisterRoute(routeId string, rpc AbstractRpcClient)

this will also consume the output channel of the abstract client

func (*WshRouter) SendEvent 

func (router *WshRouter) SendEvent(routeId string, event wps.WaveEvent)

func (*WshRouter) SetUpstreamClient 

func (router *WshRouter) SetUpstreamClient(rpc AbstractRpcClient)

func (*WshRouter) UnregisterRoute 

func (router *WshRouter) UnregisterRoute(routeId string)

func (*WshRouter) WaitForRegister 

func (router *WshRouter) WaitForRegister(ctx context.Context, routeId string) error

type WshRpc 

type WshRpc struct {
	Lock *sync.Mutex

	InputCh            chan []byte
	OutputCh           chan []byte
	RpcContext         *atomic.Pointer[wshrpc.RpcContext]
	RpcMap             map[string]*rpcData
	ServerImpl         ServerImpl
	EventListener      *EventListener
	ResponseHandlerMap map[string]*RpcResponseHandler // reqId => handler
	// contains filtered or unexported fields
}

func GetWshRpcFromContext 

func GetWshRpcFromContext(ctx context.Context) *WshRpc

func MakeWshRpc 

func MakeWshRpc(inputCh chan []byte, outputCh chan []byte, rpcCtx wshrpc.RpcContext, serverImpl ServerImpl) *WshRpc

closes outputCh when inputCh is closed/done

func SetupConnRpcClient 

func SetupConnRpcClient(conn net.Conn, serverImpl ServerImpl) (*WshRpc, chan error, error)

func SetupDomainSocketRpcClient 

func SetupDomainSocketRpcClient(sockName string, serverImpl ServerImpl) (*WshRpc, error)

func SetupTerminalRpcClient 

func SetupTerminalRpcClient(serverImpl ServerImpl) (*WshRpc, io.Reader)

returns (wshRpc, wrappedStdin)

func (*WshRpc) ClientId 

func (w *WshRpc) ClientId() string

func (*WshRpc) GetRpcContext 

func (w *WshRpc) GetRpcContext() wshrpc.RpcContext

func (*WshRpc) RecvRpcMessage 

func (w *WshRpc) RecvRpcMessage() ([]byte, bool)

func (*WshRpc) SendCommand 

func (w *WshRpc) SendCommand(command string, data any, opts *wshrpc.RpcOpts) error

no response

func (*WshRpc) SendComplexRequest 

func (w *WshRpc) SendComplexRequest(command string, data any, opts *wshrpc.RpcOpts) (rtnHandler *RpcRequestHandler, rtnErr error)

func (*WshRpc) SendRpcMessage 

func (w *WshRpc) SendRpcMessage(msg []byte)

func (*WshRpc) SendRpcRequest 

func (w *WshRpc) SendRpcRequest(command string, data any, opts *wshrpc.RpcOpts) (any, error)

single response

func (*WshRpc) SetRpcContext 

func (w *WshRpc) SetRpcContext(ctx wshrpc.RpcContext)

func (*WshRpc) SetServerImpl 

func (w *WshRpc) SetServerImpl(serverImpl ServerImpl)

type WshRpcProxy 

type WshRpcProxy struct {
	Lock         *sync.Mutex
	RpcContext   *wshrpc.RpcContext
	ToRemoteCh   chan []byte
	FromRemoteCh chan []byte
}

func MakeRpcProxy 

func MakeRpcProxy() *WshRpcProxy

func (*WshRpcProxy) GetRpcContext 

func (p *WshRpcProxy) GetRpcContext() *wshrpc.RpcContext

func (*WshRpcProxy) HandleAuthentication 

func (p *WshRpcProxy) HandleAuthentication() (*wshrpc.RpcContext, error)

func (*WshRpcProxy) RecvRpcMessage 

func (p *WshRpcProxy) RecvRpcMessage() ([]byte, bool)

func (*WshRpcProxy) SendRpcMessage 

func (p *WshRpcProxy) SendRpcMessage(msg []byte)

func (*WshRpcProxy) SetRpcContext 

func (p *WshRpcProxy) SetRpcContext(rpcCtx *wshrpc.RpcContext)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.