server

type Options ¶

type Options struct {
	Telemetry *config.TelemetryConfig
	Server    *config.AssistantServerConfig
}

type RunmeHandler ¶

type RunmeHandler struct {
	Ctx    context.Context
	Conn   *websocket.Conn
	Runner *Runner
	// contains filtered or unexported fields
}

RunmeHandler is a processor for messages received over a websocket from a single RunmeConsole element in the DOM.

There is one instance of this struct per websocket connection; i.e. each instance handles a single websocket connection. There is also 1 websocket connection per RunmeConsole element (block) in the UI. So this RunmeHandler is only handling one UI block. However, multiple commands can be sent over the websocket connection. Right now we only support non-interactive commands. So the protocol is client sends a single ExecuteRequest and then the server responds with multiple ExecuteResponses. The runnerv2service.Execute method is invoked once per ExecuteRequest; it will terminate when execution finishes. However, the UI could send additional ExecuteRequests over the same websocket connection. These could be a stop/terminate message to indicate we should abort a long running command.

However, we should also be robust to the case where the UI erroneously sends a new request before the current one has finished.

func NewRunmeHandler(ctx context.Context, conn *websocket.Conn, runner *Runner) *RunmeHandler

type Runner ¶

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

Runner lets you run commands using Runme.

func NewRunner(logger *zap.Logger) (*Runner, error)

type Server ¶

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

Server is the main server for the cloud assistant

func NewServer(opts Options, agent *ai.Agent) (*Server, error)

func (s *Server) Run() error

type SocketMessageProcessor ¶

type SocketMessageProcessor struct {
	Ctx              context.Context
	Conn             *websocket.Conn
	ExecuteRequests  chan *v2.ExecuteRequest
	ExecuteResponses chan *v2.ExecuteResponse
	// StopReading is used to signal to the readMessages goroutine that it should stop reading messages
	StopReading chan bool

	Runner *Runner
}

func NewSocketMessageProcessor(ctx context.Context) *SocketMessageProcessor

func (p *SocketMessageProcessor) Context() context.Context

func (p *SocketMessageProcessor) Recv() (*v2.ExecuteRequest, error)

func (p *SocketMessageProcessor) RecvMsg(m any) error

func (p *SocketMessageProcessor) Send(res *v2.ExecuteResponse) error

func (p *SocketMessageProcessor) SendHeader(md metadata.MD) error

func (p *SocketMessageProcessor) SendMsg(m any) error

func (p *SocketMessageProcessor) SetHeader(md metadata.MD) error

func (p *SocketMessageProcessor) SetTrailer(md metadata.MD)

type WebSocketHandler ¶

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

WebSocketHandler is a handler for websockets.

func (h *WebSocketHandler) Handler(w http.ResponseWriter, r *http.Request)