package dap

import "github.com/docker/buildx/dap"

Index

Variables

var ErrServerStopped = errors.New("dap: server stopped")

Types

type Adapter

type Adapter[C LaunchConfig] struct {
	// contains filtered or unexported fields
}

func New

func New[C LaunchConfig]() *Adapter[C]

func (*Adapter[C]) ConfigurationDone

func (d *Adapter[C]) ConfigurationDone(c Context, req *dap.ConfigurationDoneRequest, resp *dap.ConfigurationDoneResponse) error

func (*Adapter[C]) Continue

func (d *Adapter[C]) Continue(c Context, req *dap.ContinueRequest, resp *dap.ContinueResponse) error

func (*Adapter[C]) Disconnect

func (d *Adapter[C]) Disconnect(c Context, req *dap.DisconnectRequest, resp *dap.DisconnectResponse) error

func (*Adapter[C]) Evaluate

func (d *Adapter[C]) Evaluate(ctx Context, req *dap.EvaluateRequest, resp *dap.EvaluateResponse) error

func (*Adapter[C]) EvaluateResult

func (d *Adapter[C]) EvaluateResult(ctx context.Context, name string, c gateway.Client, res *gateway.Result, inputs build.Inputs) error

func (*Adapter[C]) Handler

func (d *Adapter[C]) Handler() build.Handler

func (*Adapter[C]) Initialize

func (d *Adapter[C]) Initialize(c Context, req *dap.InitializeRequest, resp *dap.InitializeResponse) error

func (*Adapter[C]) Launch

func (d *Adapter[C]) Launch(c Context, req *dap.LaunchRequest, resp *dap.LaunchResponse) error

func (*Adapter[C]) Next

func (d *Adapter[C]) Next(c Context, req *dap.NextRequest, resp *dap.NextResponse) error

func (*Adapter[C]) Out

func (d *Adapter[C]) Out() io.Writer

func (*Adapter[C]) Scopes

func (d *Adapter[C]) Scopes(c Context, req *dap.ScopesRequest, resp *dap.ScopesResponse) error

func (*Adapter[C]) SetBreakpoints

func (d *Adapter[C]) SetBreakpoints(c Context, req *dap.SetBreakpointsRequest, resp *dap.SetBreakpointsResponse) error

func (*Adapter[C]) Source

func (d *Adapter[C]) Source(c Context, req *dap.SourceRequest, resp *dap.SourceResponse) error

func (*Adapter[C]) StackTrace

func (d *Adapter[C]) StackTrace(c Context, req *dap.StackTraceRequest, resp *dap.StackTraceResponse) error

func (*Adapter[C]) Start

func (d *Adapter[C]) Start(ctx context.Context, conn Conn) (C, error)

func (*Adapter[C]) StepIn

func (d *Adapter[C]) StepIn(c Context, req *dap.StepInRequest, resp *dap.StepInResponse) error

func (*Adapter[C]) StepOut

func (d *Adapter[C]) StepOut(c Context, req *dap.StepOutRequest, resp *dap.StepOutResponse) error

func (*Adapter[C]) Stop

func (d *Adapter[C]) Stop() error

func (*Adapter[C]) Threads

func (d *Adapter[C]) Threads(c Context, req *dap.ThreadsRequest, resp *dap.ThreadsResponse) error

func (*Adapter[C]) Variables

func (d *Adapter[C]) Variables(c Context, req *dap.VariablesRequest, resp *dap.VariablesResponse) error

type Conn

type Conn interface {
	SendMsg(m dap.Message) error
	RecvMsg(ctx context.Context) (dap.Message, error)
	io.Closer
}

func NewConn

func NewConn(rd io.Reader, wr io.Writer) Conn

type Context

type Context interface {
	context.Context
	C() chan<- dap.Message
	Go(f func(c Context)) bool
	Request(req dap.RequestMessage) dap.ResponseMessage
}

type Handler

type Handler struct {
	Initialize        HandlerFunc[*dap.InitializeRequest, *dap.InitializeResponse]
	Launch            HandlerFunc[*dap.LaunchRequest, *dap.LaunchResponse]
	Attach            HandlerFunc[*dap.AttachRequest, *dap.AttachResponse]
	SetBreakpoints    HandlerFunc[*dap.SetBreakpointsRequest, *dap.SetBreakpointsResponse]
	ConfigurationDone HandlerFunc[*dap.ConfigurationDoneRequest, *dap.ConfigurationDoneResponse]
	Disconnect        HandlerFunc[*dap.DisconnectRequest, *dap.DisconnectResponse]
	Terminate         HandlerFunc[*dap.TerminateRequest, *dap.TerminateResponse]
	Continue          HandlerFunc[*dap.ContinueRequest, *dap.ContinueResponse]
	Next              HandlerFunc[*dap.NextRequest, *dap.NextResponse]
	StepIn            HandlerFunc[*dap.StepInRequest, *dap.StepInResponse]
	StepOut           HandlerFunc[*dap.StepOutRequest, *dap.StepOutResponse]
	Restart           HandlerFunc[*dap.RestartRequest, *dap.RestartResponse]
	Threads           HandlerFunc[*dap.ThreadsRequest, *dap.ThreadsResponse]
	StackTrace        HandlerFunc[*dap.StackTraceRequest, *dap.StackTraceResponse]
	Scopes            HandlerFunc[*dap.ScopesRequest, *dap.ScopesResponse]
	Variables         HandlerFunc[*dap.VariablesRequest, *dap.VariablesResponse]
	Evaluate          HandlerFunc[*dap.EvaluateRequest, *dap.EvaluateResponse]
	Source            HandlerFunc[*dap.SourceRequest, *dap.SourceResponse]
}

type HandlerFunc

type HandlerFunc[Req dap.RequestMessage, Resp dap.ResponseMessage] func(c Context, req Req, resp Resp) error

func (HandlerFunc[Req, Resp]) Do

func (h HandlerFunc[Req, Resp]) Do(c Context, req Req) (resp Resp, err error)

type LaunchConfig

type LaunchConfig interface {
	GetConfig() common.Config
}

type RequestCallback

type RequestCallback func(c Context, resp dap.ResponseMessage)

type Server

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

func NewServer

func NewServer(h Handler) *Server

func (*Server) Go

func (s *Server) Go(fn func(c Context)) bool

func (*Server) Serve

func (s *Server) Serve(ctx context.Context, conn Conn) error

func (*Server) Stop

func (s *Server) Stop()

Source Files

adapter.go config.go conn.go eval.go handler.go server.go thread.go variables.go

Directories

PathSynopsis
dap/common
Version
v0.26.1 (latest)
Published
Jul 22, 2025
Platform
linux/amd64
Imports
29 packages
Last checked
2 hours ago

Tools for package owners.