You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
111 lines
2.9 KiB
Go
111 lines
2.9 KiB
Go
package localapiservice
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"time"
|
|
|
|
"tailscale.com/ipn/ipnlocal"
|
|
)
|
|
|
|
type LocalAPIService struct {
|
|
h http.Handler
|
|
}
|
|
|
|
func New(h http.Handler) *LocalAPIService {
|
|
return &LocalAPIService{h: h}
|
|
}
|
|
|
|
// Call calls the given endpoint on the local API using the given HTTP method
|
|
// optionally sending the given body. It returns a Response representing the
|
|
// result of the call and an error if the call could not be completed or the
|
|
// local API returned a status code in the 400 series or greater.
|
|
// Note - Response includes a response body available from the Body method, it
|
|
// is the caller's responsibility to close this.
|
|
func (cl *LocalAPIService) Call(ctx context.Context, method, endpoint string, body io.Reader) (*Response, error) {
|
|
req, err := http.NewRequestWithContext(ctx, method, endpoint, body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating new request for %s: %w", endpoint, err)
|
|
}
|
|
deadline, _ := ctx.Deadline()
|
|
pipeReader, pipeWriter := net.Pipe()
|
|
pipeReader.SetDeadline(deadline)
|
|
pipeWriter.SetDeadline(deadline)
|
|
|
|
resp := &Response{
|
|
headers: http.Header{},
|
|
status: http.StatusOK,
|
|
bodyReader: pipeReader,
|
|
bodyWriter: pipeWriter,
|
|
startWritingBody: make(chan interface{}),
|
|
}
|
|
|
|
go func() {
|
|
cl.h.ServeHTTP(resp, req)
|
|
resp.Flush()
|
|
pipeWriter.Close()
|
|
}()
|
|
|
|
select {
|
|
case <-resp.startWritingBody:
|
|
if resp.StatusCode() >= 400 {
|
|
return resp, fmt.Errorf("request failed with status code %d", resp.StatusCode())
|
|
}
|
|
return resp, nil
|
|
case <-ctx.Done():
|
|
return nil, fmt.Errorf("timeout for %s", endpoint)
|
|
}
|
|
}
|
|
|
|
func (s *LocalAPIService) GetBugReportID(ctx context.Context, bugReportChan chan<- string, fallbackLog string) {
|
|
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
|
|
defer cancel()
|
|
r, err := s.Call(ctx, "POST", "/localapi/v0/bugreport", nil)
|
|
defer r.Body().Close()
|
|
|
|
if err != nil {
|
|
log.Printf("get bug report: %s", err)
|
|
bugReportChan <- fallbackLog
|
|
return
|
|
}
|
|
logBytes, err := io.ReadAll(r.Body())
|
|
if err != nil {
|
|
log.Printf("read bug report: %s", err)
|
|
bugReportChan <- fallbackLog
|
|
return
|
|
}
|
|
bugReportChan <- string(logBytes)
|
|
}
|
|
|
|
func (s *LocalAPIService) Login(ctx context.Context, backend *ipnlocal.LocalBackend) {
|
|
ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
|
|
defer cancel()
|
|
r, err := s.Call(ctx, "POST", "/localapi/v0/login-interactive", nil)
|
|
defer r.Body().Close()
|
|
|
|
if err != nil {
|
|
log.Printf("login: %s", err)
|
|
backend.StartLoginInteractive()
|
|
}
|
|
}
|
|
|
|
func (s *LocalAPIService) Logout(ctx context.Context, backend *ipnlocal.LocalBackend) error {
|
|
ctx, cancel := context.WithTimeout(ctx, 60*time.Second)
|
|
defer cancel()
|
|
r, err := s.Call(ctx, "POST", "/localapi/v0/logout", nil)
|
|
defer r.Body().Close()
|
|
|
|
if err != nil {
|
|
log.Printf("logout: %s", err)
|
|
logoutctx, logoutcancel := context.WithTimeout(ctx, 5*time.Minute)
|
|
defer logoutcancel()
|
|
backend.Logout(logoutctx)
|
|
}
|
|
|
|
return err
|
|
}
|