2022-10-09 22:48:18 +00:00
|
|
|
package nixstore
|
|
|
|
|
|
|
|
import (
|
2023-08-23 23:00:44 +00:00
|
|
|
"bytes"
|
2022-10-09 22:48:18 +00:00
|
|
|
"encoding/base64"
|
2023-08-23 23:00:44 +00:00
|
|
|
"encoding/hex"
|
|
|
|
"errors"
|
2022-10-09 22:48:18 +00:00
|
|
|
"fmt"
|
2023-08-17 02:51:18 +00:00
|
|
|
"io"
|
2023-08-23 23:00:44 +00:00
|
|
|
"log"
|
2022-10-09 22:48:18 +00:00
|
|
|
"net"
|
|
|
|
"path"
|
|
|
|
"strings"
|
2022-10-10 00:28:26 +00:00
|
|
|
"sync"
|
2022-10-09 22:48:18 +00:00
|
|
|
|
2024-11-16 15:30:41 +00:00
|
|
|
"git.lukegb.com/lukegb/depot/go/nix/nar"
|
|
|
|
"git.lukegb.com/lukegb/depot/go/nix/nar/narinfo"
|
|
|
|
"git.lukegb.com/lukegb/depot/go/nix/nixdrv"
|
|
|
|
"git.lukegb.com/lukegb/depot/go/nix/nixwire"
|
2022-10-09 22:48:18 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
DaemonSock = "/nix/var/nix/daemon-socket/socket"
|
|
|
|
WorkerMagic1 = 0x6e697863
|
|
|
|
WorkerMagic2 = 0x6478696f
|
2023-08-23 23:00:44 +00:00
|
|
|
ProtocolVersion = 0x120 // 0x115
|
2022-10-09 22:48:18 +00:00
|
|
|
|
2023-08-23 23:00:44 +00:00
|
|
|
WopAddMultipleToStore = 44
|
|
|
|
WopAddToStoreNar = 39
|
2023-08-17 02:51:18 +00:00
|
|
|
WopBuildDerivation = 36
|
|
|
|
WopEnsurePath = 10
|
2023-08-23 23:00:44 +00:00
|
|
|
WopIsValidPath = 1
|
|
|
|
WopNarFromPath = 38
|
2022-10-09 22:48:18 +00:00
|
|
|
WopQueryPathInfo = 26
|
|
|
|
WopQuerySubstitutablePathInfo = 21
|
2023-08-23 23:00:44 +00:00
|
|
|
WopQueryValidDerivers = 33
|
|
|
|
WopQueryValidPaths = 31
|
2023-08-17 02:51:18 +00:00
|
|
|
|
|
|
|
MaxBuf = 1024 * 1024 // 1 MB
|
2022-10-09 22:48:18 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
type Daemon struct {
|
2023-08-27 22:45:46 +00:00
|
|
|
name string
|
|
|
|
|
2023-08-17 23:48:07 +00:00
|
|
|
conn io.Closer
|
2022-10-09 22:48:18 +00:00
|
|
|
w *nixwire.Serializer
|
|
|
|
r *nixwire.Deserializer
|
2022-10-10 00:28:26 +00:00
|
|
|
mu sync.Mutex
|
|
|
|
err error
|
2023-08-23 23:00:44 +00:00
|
|
|
|
|
|
|
peerMinorVersion int
|
2022-10-09 22:48:18 +00:00
|
|
|
}
|
|
|
|
|
2023-08-19 21:14:04 +00:00
|
|
|
type PathNotValidError struct{ Path string }
|
|
|
|
|
|
|
|
func (err PathNotValidError) Error() string {
|
|
|
|
return fmt.Sprintf("path %q is not valid", err.Path)
|
|
|
|
}
|
|
|
|
|
2023-08-23 23:00:44 +00:00
|
|
|
func (d *Daemon) Err() error {
|
|
|
|
return d.err
|
|
|
|
}
|
|
|
|
|
2022-10-09 22:48:18 +00:00
|
|
|
func (d *Daemon) NARInfo(storePath string) (*narinfo.NarInfo, error) {
|
2022-10-10 00:28:26 +00:00
|
|
|
d.mu.Lock()
|
|
|
|
defer d.mu.Unlock()
|
|
|
|
|
2023-08-23 23:00:44 +00:00
|
|
|
if _, err := d.writeOp(WopQueryPathInfo); err != nil {
|
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return nil, fmt.Errorf("writing worker op WopQueryPathInfo: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteString(storePath); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return nil, fmt.Errorf("writing store path query %v: %w", storePath, err)
|
|
|
|
}
|
|
|
|
|
2023-08-17 02:51:18 +00:00
|
|
|
if err := d.processStderr(nil, nil, nil); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return nil, fmt.Errorf("reading stderr from WopQueryPathInfo: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
validInt, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return nil, fmt.Errorf("reading path validity: %w", err)
|
|
|
|
}
|
|
|
|
valid := validInt == uint64(1)
|
|
|
|
if !valid {
|
2023-08-19 21:14:04 +00:00
|
|
|
return nil, PathNotValidError{storePath}
|
2022-10-09 22:48:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ni := &narinfo.NarInfo{
|
|
|
|
StorePath: storePath,
|
|
|
|
}
|
|
|
|
if ni.Deriver, err = d.r.ReadString(); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return nil, fmt.Errorf("reading deriver: %w", err)
|
|
|
|
}
|
2022-11-08 12:33:17 +00:00
|
|
|
ni.Deriver = path.Base(ni.Deriver)
|
2023-01-15 02:06:51 +00:00
|
|
|
if ni.Deriver == "." {
|
|
|
|
ni.Deriver = ""
|
|
|
|
}
|
2022-10-09 22:48:18 +00:00
|
|
|
|
|
|
|
hashStr, err := d.r.ReadString()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return nil, fmt.Errorf("reading NAR hash: %w", err)
|
|
|
|
}
|
|
|
|
if ni.NarHash, err = narinfo.HashFromString("sha256:" + hashStr); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return nil, fmt.Errorf("parsing NAR hash %q: %w", hashStr, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
refs, err := d.r.ReadStrings()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return nil, fmt.Errorf("reading referrers: %w", err)
|
|
|
|
}
|
|
|
|
for n, ref := range refs {
|
|
|
|
refs[n] = path.Base(ref)
|
|
|
|
}
|
|
|
|
ni.References = refs
|
|
|
|
|
|
|
|
if _, err := d.r.ReadUint64(); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return nil, fmt.Errorf("reading registration time: %w", err)
|
|
|
|
}
|
|
|
|
if ni.NarSize, err = d.r.ReadUint64(); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return nil, fmt.Errorf("reading narsize: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.r.ReadUint64(); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return nil, fmt.Errorf("reading ultimate: %w", err)
|
|
|
|
}
|
|
|
|
sigs, err := d.r.ReadStrings()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return nil, fmt.Errorf("reading sigs: %w", err)
|
|
|
|
}
|
2023-08-23 23:00:44 +00:00
|
|
|
ni.CA, err = d.r.ReadString()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return nil, fmt.Errorf("reading CA: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
ni.Sig = make(map[string][]byte)
|
|
|
|
for _, sigStr := range sigs {
|
|
|
|
sigBits := strings.Split(sigStr, ":")
|
|
|
|
sigHash, err := base64.StdEncoding.DecodeString(sigBits[1])
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("decoding signature %q: %w", sigStr, err)
|
|
|
|
}
|
|
|
|
ni.Sig[sigBits[0]] = sigHash
|
|
|
|
}
|
|
|
|
|
|
|
|
return ni, nil
|
|
|
|
}
|
|
|
|
|
2023-08-23 23:00:44 +00:00
|
|
|
func (d *Daemon) NARFromPath(storePath string) (io.ReadCloser, error) {
|
|
|
|
d.mu.Lock()
|
|
|
|
defer d.mu.Unlock()
|
|
|
|
|
|
|
|
if _, err := d.writeOp(WopNarFromPath); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return nil, fmt.Errorf("writing worker op WopNarFromPath: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteString(storePath); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return nil, fmt.Errorf("writing store path query %v: %w", storePath, err)
|
|
|
|
}
|
|
|
|
if err := d.processStderr(nil, nil, nil); err != nil {
|
|
|
|
return nil, fmt.Errorf("waiting for NAR packing: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
pr, pw := io.Pipe()
|
|
|
|
go func() {
|
|
|
|
err := nar.Unpack(io.TeeReader(d.r.Reader, pw), nar.NullFS{}, "irrelevant")
|
|
|
|
if err != nil {
|
|
|
|
pw.CloseWithError(err)
|
|
|
|
} else {
|
|
|
|
pw.Close()
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
return io.NopCloser(pr), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *Daemon) writeOp(op uint64) (int64, error) {
|
|
|
|
return d.w.WriteUint64(op)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *Daemon) ValidPaths(storePaths []string) ([]string, error) {
|
|
|
|
d.mu.Lock()
|
|
|
|
defer d.mu.Unlock()
|
|
|
|
|
|
|
|
if _, err := d.writeOp(WopQueryValidPaths); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return nil, fmt.Errorf("writing worker op WopQueryValidPaths: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteStrings(storePaths); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return nil, fmt.Errorf("writing store path query %v: %w", storePaths, err)
|
|
|
|
}
|
|
|
|
if d.peerMinorVersion >= 27 {
|
|
|
|
// Substitute flag
|
|
|
|
if _, err := d.w.WriteUint64(0); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return nil, fmt.Errorf("writing substitute flag: %w", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := d.processStderr(nil, nil, nil); err != nil {
|
|
|
|
return nil, fmt.Errorf("reading stderr from WopQueryValidPaths: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
validPaths, err := d.r.ReadStrings()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
|
|
|
return nil, fmt.Errorf("reading valid paths: %w", err)
|
|
|
|
}
|
|
|
|
return validPaths, nil
|
|
|
|
}
|
|
|
|
|
2022-10-09 22:48:18 +00:00
|
|
|
func (d *Daemon) Close() error {
|
2022-10-10 00:28:26 +00:00
|
|
|
d.mu.Lock()
|
|
|
|
defer d.mu.Unlock()
|
|
|
|
|
2022-10-09 22:48:18 +00:00
|
|
|
return d.conn.Close()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *Daemon) readFields() ([]any, error) {
|
|
|
|
fieldsSz, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("reading fields count: %w", err)
|
|
|
|
}
|
|
|
|
var fields []any
|
|
|
|
for n := 0; n < int(fieldsSz); n++ {
|
|
|
|
fieldTyp, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("reading field %d type: %w", n, err)
|
|
|
|
}
|
|
|
|
switch fieldTyp {
|
|
|
|
case 0: // tInt
|
|
|
|
fieldVal, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("reading field %d int: %w", n, err)
|
|
|
|
}
|
|
|
|
fields = append(fields, fieldVal)
|
|
|
|
case 1: // tString
|
|
|
|
fieldVal, err := d.r.ReadString()
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("reading field %d str: %w", n, err)
|
|
|
|
}
|
|
|
|
fields = append(fields, fieldVal)
|
|
|
|
default:
|
|
|
|
return nil, fmt.Errorf("reading field %d: unsupported field type %x", n, fieldTyp)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return fields, nil
|
|
|
|
}
|
|
|
|
|
2023-08-19 21:14:04 +00:00
|
|
|
type NixError struct {
|
|
|
|
Code uint64
|
|
|
|
Message string
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ne NixError) Error() string {
|
|
|
|
return fmt.Sprintf("nix error %d: %v", ne.Code, ne.Message)
|
|
|
|
}
|
|
|
|
|
2023-08-17 02:51:18 +00:00
|
|
|
func (d *Daemon) processStderr(al *ActivityLogger, stdout io.Writer, stdin io.Reader) error {
|
2022-10-09 22:48:18 +00:00
|
|
|
for {
|
|
|
|
msg, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("read stderr msg code: %w", err)
|
|
|
|
}
|
|
|
|
switch msg {
|
|
|
|
case 0x64617416: // STDERR_WRITE
|
2023-08-17 02:51:18 +00:00
|
|
|
if stdout == nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return fmt.Errorf("STDERR_WRITE requested")
|
|
|
|
}
|
|
|
|
bs, err := d.r.ReadBytes()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return fmt.Errorf("read bytes: %w", err)
|
|
|
|
}
|
|
|
|
_, err = stdout.Write(bs)
|
2022-10-09 22:48:18 +00:00
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return fmt.Errorf("write bytes into stdout: %w", err)
|
2022-10-09 22:48:18 +00:00
|
|
|
}
|
|
|
|
case 0x64617461: // STDERR_READ
|
2023-08-17 02:51:18 +00:00
|
|
|
if stdin == nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return fmt.Errorf("STDERR_READ requested")
|
|
|
|
}
|
|
|
|
readSizeU64, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return fmt.Errorf("STDERR_READ reading uint64: %w", err)
|
|
|
|
}
|
|
|
|
readSize := int(readSizeU64)
|
|
|
|
if readSize > MaxBuf {
|
|
|
|
readSize = MaxBuf
|
|
|
|
}
|
|
|
|
buf := make([]byte, readSize)
|
|
|
|
readSize, err = stdin.Read(buf)
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return fmt.Errorf("STDERR_READ reading from stdin: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteBytes(buf[:readSize]); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return fmt.Errorf("STDERR_READ writing stdin to socket: %w", err)
|
|
|
|
}
|
2022-10-09 22:48:18 +00:00
|
|
|
case 0x63787470: // STDERR_ERROR
|
2023-08-23 23:00:44 +00:00
|
|
|
if d.peerMinorVersion >= 26 {
|
|
|
|
errStr, err := d.r.ReadString()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("STDERR_ERROR reading 'Error' string: %w", err)
|
|
|
|
}
|
|
|
|
errLevel, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("STDERR_ERROR reading error level: %w", err)
|
|
|
|
}
|
|
|
|
errName, err := d.r.ReadString()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("STDERR_ERROR reading error name: %w", err)
|
|
|
|
}
|
|
|
|
errMsg, err := d.r.ReadString()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("STDERR_ERROR reading error message: %w", err)
|
|
|
|
}
|
|
|
|
errPos, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("STDERR_ERROR reading error position: %w", err)
|
|
|
|
}
|
|
|
|
log.Printf("error? Error=%s Level=%d Name=%s Msg=%s Pos=%d", errStr, errLevel, errName, errMsg, errPos)
|
|
|
|
errTraceNum, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("STDERR_ERROR reading trace count: %w", err)
|
|
|
|
}
|
|
|
|
for n := 0; n < int(errTraceNum); n++ {
|
|
|
|
tracePos, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("STDERR_ERROR reading trace position: %w", err)
|
|
|
|
}
|
|
|
|
traceHint, err := d.r.ReadString()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("STDERR_ERROR reading trace hint: %w", err)
|
|
|
|
}
|
|
|
|
log.Printf("error? trace %d/%d: Pos=%d Hint=%s", n+1, errTraceNum, tracePos, traceHint)
|
|
|
|
}
|
|
|
|
return fmt.Errorf("nix Error=%s Level=%d Name=%s Msg=%s Pos=%d", errStr, errLevel, errName, errMsg, errPos)
|
|
|
|
} else {
|
|
|
|
errStr, err := d.r.ReadString()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("STDERR_ERROR reading error string: %w", err)
|
|
|
|
}
|
|
|
|
status, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("STDERR_ERROR reading uint64: %w", err)
|
|
|
|
}
|
|
|
|
al.AddError(status, errStr)
|
|
|
|
return NixError{status, errStr}
|
2022-10-09 22:48:18 +00:00
|
|
|
}
|
|
|
|
case 0x6f6c6d67: // STDERR_NEXT
|
2023-08-17 02:51:18 +00:00
|
|
|
msg, err := d.r.ReadString()
|
2022-10-09 22:48:18 +00:00
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return fmt.Errorf("STDERR_NEXT reading log string: %w", err)
|
2022-10-09 22:48:18 +00:00
|
|
|
}
|
2023-08-17 02:51:18 +00:00
|
|
|
al.AddLog(msg)
|
2022-10-09 22:48:18 +00:00
|
|
|
case 0x53545254: // STDERR_START_ACTIVITY
|
|
|
|
activity, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("STDERR_START_ACTIVITY reading ActivityId: %w", err)
|
|
|
|
}
|
|
|
|
lvl, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("STDERR_START_ACTIVITY reading level: %w", err)
|
|
|
|
}
|
2023-08-17 02:51:18 +00:00
|
|
|
actTypeU64, err := d.r.ReadUint64()
|
2022-10-09 22:48:18 +00:00
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("STDERR_START_ACTIVITY reading activity type: %w", err)
|
|
|
|
}
|
2023-08-17 02:51:18 +00:00
|
|
|
actType := ActivityType(actTypeU64)
|
2022-10-09 22:48:18 +00:00
|
|
|
s, err := d.r.ReadString()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("STDERR_START_ACTIVITY reading s: %w", err)
|
|
|
|
}
|
|
|
|
fields, err := d.readFields()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("STDERR_START_ACTIVITY fields: %w", err)
|
|
|
|
}
|
|
|
|
parentActivity, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("STDERR_START_ACTIVITY reading parent activity: %w", err)
|
|
|
|
}
|
2023-08-17 02:51:18 +00:00
|
|
|
al.StartActivity(actType, ActivityMeta{
|
|
|
|
ActivityID: activity,
|
|
|
|
Level: lvl,
|
|
|
|
String: s,
|
|
|
|
Fields: fields,
|
|
|
|
ParentActivityID: parentActivity,
|
|
|
|
})
|
2022-10-09 22:48:18 +00:00
|
|
|
case 0x53544f50: // STDERR_STOP_ACTIVITY
|
|
|
|
activity, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("STDERR_STOP_ACTIVITY reading ActivityId: %w", err)
|
|
|
|
}
|
2023-08-17 02:51:18 +00:00
|
|
|
al.EndActivity(al.Activity(activity))
|
2022-10-09 22:48:18 +00:00
|
|
|
case 0x52534c54: // STDERR_RESULT
|
|
|
|
activity, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("STDERR_RESULT reading ActivityId: %w", err)
|
|
|
|
}
|
2023-08-17 02:51:18 +00:00
|
|
|
resultTypU64, err := d.r.ReadUint64()
|
2022-10-09 22:48:18 +00:00
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("STDERR_RESULT reading result: %w", err)
|
|
|
|
}
|
2023-08-17 02:51:18 +00:00
|
|
|
resultTyp := ResultType(resultTypU64)
|
2022-10-09 22:48:18 +00:00
|
|
|
fields, err := d.readFields()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("STDERR_RESULT fields: %w", err)
|
|
|
|
}
|
2023-08-17 02:51:18 +00:00
|
|
|
al.ActivityResult(al.Activity(activity), resultTyp, fields)
|
2022-10-09 22:48:18 +00:00
|
|
|
case 0x616c7473: // STDERR_LAST
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *Daemon) hello() error {
|
|
|
|
_, err := d.w.WriteUint64(WorkerMagic1)
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("writing magic 1: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
magic2, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("reading magic 2: %w", err)
|
|
|
|
}
|
|
|
|
if magic2 != WorkerMagic2 {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("magic 2 mismatch: got %x, wanted %x", magic2, WorkerMagic2)
|
|
|
|
}
|
|
|
|
|
|
|
|
daemonVersion, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("reading daemon version: %w", err)
|
|
|
|
}
|
|
|
|
majorVersion := int((daemonVersion >> 8) & 0xff)
|
|
|
|
minorVersion := int(daemonVersion & 0xff)
|
|
|
|
if majorVersion != 1 {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("daemon major version mismatch: got %d, want 1", majorVersion)
|
|
|
|
}
|
|
|
|
if minorVersion < 21 {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("daemon minor version too old: got %d, want at least 21", minorVersion)
|
|
|
|
}
|
2023-08-23 23:00:44 +00:00
|
|
|
d.peerMinorVersion = minorVersion
|
2022-10-09 22:48:18 +00:00
|
|
|
|
|
|
|
if _, err := d.w.WriteUint64(ProtocolVersion); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("writing protocol version: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if _, err := d.w.WriteUint64(0); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("writing obsolete CPU affinity: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteUint64(0); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2022-10-09 22:48:18 +00:00
|
|
|
return fmt.Errorf("writing obsolete reserveSpace: %w", err)
|
|
|
|
}
|
|
|
|
|
2023-08-17 02:51:18 +00:00
|
|
|
return d.processStderr(nil, nil, nil)
|
|
|
|
}
|
|
|
|
|
2023-08-23 23:00:44 +00:00
|
|
|
func (d *Daemon) IsValidPath(at *ActivityTracker, storePath string) (bool, error) {
|
|
|
|
al := at.StartAction(fmt.Sprintf("IsValidPath(%q)", storePath))
|
|
|
|
defer al.Close()
|
|
|
|
|
|
|
|
d.mu.Lock()
|
|
|
|
defer d.mu.Unlock()
|
|
|
|
|
|
|
|
if _, err := d.writeOp(WopIsValidPath); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return false, fmt.Errorf("writing worker op WopIsValidPath: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteString(storePath); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return false, fmt.Errorf("writing store path %v: %w", storePath, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := d.processStderr(al, nil, nil); err != nil {
|
|
|
|
return false, fmt.Errorf("reading stderr from WopIsValidPath: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
validInt, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
|
|
|
return false, fmt.Errorf("reading path validity: %w", err)
|
|
|
|
}
|
|
|
|
return validInt != 0, nil
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2023-08-17 02:51:18 +00:00
|
|
|
func (d *Daemon) EnsurePath(at *ActivityTracker, storePath string) error {
|
|
|
|
al := at.StartAction(fmt.Sprintf("EnsurePath(%q)", storePath))
|
|
|
|
defer al.Close()
|
|
|
|
|
|
|
|
d.mu.Lock()
|
|
|
|
defer d.mu.Unlock()
|
|
|
|
|
2023-08-23 23:00:44 +00:00
|
|
|
if _, err := d.writeOp(WopEnsurePath); err != nil {
|
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return fmt.Errorf("writing worker op WopEnsurePath: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteString(storePath); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return fmt.Errorf("writing store path %v: %w", storePath, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := d.processStderr(al, nil, nil); err != nil {
|
|
|
|
return fmt.Errorf("reading stderr from WopEnsurePath: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
validInt, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return fmt.Errorf("reading path validity: %w", err)
|
|
|
|
}
|
|
|
|
if validInt != 1 {
|
2023-08-23 23:00:44 +00:00
|
|
|
return PathNotValidError{storePath}
|
2023-08-17 02:51:18 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
type BuildMode uint64
|
|
|
|
|
|
|
|
const (
|
|
|
|
BMNormal BuildMode = iota
|
|
|
|
BMRepair
|
|
|
|
BMCheck
|
|
|
|
)
|
|
|
|
|
|
|
|
func (bm BuildMode) String() string {
|
|
|
|
return map[BuildMode]string{
|
|
|
|
BMNormal: "normal",
|
|
|
|
BMRepair: "repair",
|
|
|
|
BMCheck: "check",
|
|
|
|
}[bm]
|
|
|
|
}
|
|
|
|
|
|
|
|
type BuildResultStatus uint64
|
|
|
|
|
|
|
|
const (
|
|
|
|
BRSBuilt BuildResultStatus = iota
|
|
|
|
BRSSubstituted
|
|
|
|
BRSAlreadyValid
|
|
|
|
BRSPermanentFailure
|
|
|
|
BRSInputRejected
|
|
|
|
BRSOutputRejected
|
|
|
|
BRSTransientFailure
|
|
|
|
BRSTimedOut
|
|
|
|
BRSMiscFailure
|
|
|
|
BRSDependencyFailed
|
|
|
|
BRSLogLimitExceeded
|
|
|
|
BRSNotDeterministic
|
|
|
|
)
|
|
|
|
|
|
|
|
func (brs BuildResultStatus) String() string {
|
|
|
|
return map[BuildResultStatus]string{
|
|
|
|
BRSBuilt: "built",
|
|
|
|
BRSSubstituted: "substituted",
|
|
|
|
BRSAlreadyValid: "already valid",
|
|
|
|
BRSPermanentFailure: "permanent failure",
|
|
|
|
BRSInputRejected: "input rejected",
|
|
|
|
BRSOutputRejected: "output rejected",
|
|
|
|
BRSTransientFailure: "transient failure",
|
|
|
|
BRSTimedOut: "timed out",
|
|
|
|
BRSMiscFailure: "misc failure",
|
|
|
|
BRSDependencyFailed: "dependency failed",
|
|
|
|
BRSLogLimitExceeded: "log limit exceeded",
|
|
|
|
BRSNotDeterministic: "not deterministic",
|
|
|
|
}[brs]
|
|
|
|
}
|
|
|
|
|
|
|
|
func (brs BuildResultStatus) IsSuccess() bool {
|
|
|
|
switch brs {
|
|
|
|
case BRSBuilt, BRSSubstituted, BRSAlreadyValid:
|
|
|
|
return true
|
|
|
|
default:
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *Daemon) BuildDerivation(at *ActivityTracker, derivationPath string, derivation *nixdrv.BasicDerivation, buildMode BuildMode) (BuildResultStatus, error) {
|
|
|
|
al := at.StartAction(fmt.Sprintf("BuildDerivation(%q, %q)", derivationPath, buildMode))
|
|
|
|
defer al.Close()
|
|
|
|
|
|
|
|
d.mu.Lock()
|
|
|
|
defer d.mu.Unlock()
|
|
|
|
|
2023-08-23 23:00:44 +00:00
|
|
|
if _, err := d.writeOp(WopBuildDerivation); err != nil {
|
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return BRSMiscFailure, fmt.Errorf("writing worker op WopBuildDerivation: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteString(derivationPath); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return BRSMiscFailure, fmt.Errorf("writing derivation store path %v: %w", derivationPath, err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteDerivation(derivation); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return BRSMiscFailure, fmt.Errorf("writing derivation content of %v: %w", derivationPath, err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteUint64(uint64(buildMode)); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return BRSMiscFailure, fmt.Errorf("writing build mode %v: %w", buildMode, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := d.processStderr(al, nil, nil); err != nil {
|
|
|
|
return BRSMiscFailure, fmt.Errorf("reading stderr from WopBuildDerivation: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
buildStatusU64, err := d.r.ReadUint64()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return BRSMiscFailure, fmt.Errorf("reading build status code: %w", err)
|
|
|
|
}
|
|
|
|
buildStatus := BuildResultStatus(buildStatusU64)
|
|
|
|
buildErrorMsg, err := d.r.ReadString()
|
|
|
|
if err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
d.err = err
|
2023-08-17 02:51:18 +00:00
|
|
|
return BRSMiscFailure, fmt.Errorf("reading build error message: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if !buildStatus.IsSuccess() {
|
|
|
|
return buildStatus, fmt.Errorf("%s: %s", buildStatus, buildErrorMsg)
|
|
|
|
}
|
|
|
|
|
|
|
|
return buildStatus, nil
|
2022-10-09 22:48:18 +00:00
|
|
|
}
|
|
|
|
|
2023-08-23 23:00:44 +00:00
|
|
|
func (d *Daemon) writeNarInfo(ni *narinfo.NarInfo, w *nixwire.Serializer) error {
|
|
|
|
|
|
|
|
storeRoot := path.Dir(ni.StorePath)
|
|
|
|
|
|
|
|
if _, err := w.WriteString(ni.StorePath); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing store path: %w", err)
|
|
|
|
}
|
|
|
|
var deriverPath string
|
|
|
|
if ni.Deriver != "" {
|
|
|
|
deriverPath = path.Join(storeRoot, ni.Deriver)
|
|
|
|
}
|
|
|
|
if _, err := w.WriteString(deriverPath); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing deriver: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := w.WriteString(hex.EncodeToString(ni.NarHash.Hash)); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing NAR hash: %w", err)
|
|
|
|
}
|
|
|
|
rootedRefs := make([]string, len(ni.References))
|
|
|
|
for n, ref := range ni.References {
|
|
|
|
rootedRefs[n] = path.Join(storeRoot, ref)
|
|
|
|
}
|
|
|
|
if _, err := w.WriteStrings(rootedRefs); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing references: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := w.WriteUint64(0); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing dummy registration time: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := w.WriteUint64(ni.NarSize); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing NAR size: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := w.WriteUint64(1); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing ultimate (true): %w", err)
|
|
|
|
}
|
|
|
|
if _, err := w.WriteStrings(ni.Sigs()); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing signatures: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := w.WriteString(ni.CA); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing content-addressable: %w", err)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
type bufferingReader struct {
|
|
|
|
r io.Reader
|
|
|
|
}
|
|
|
|
|
|
|
|
func (r *bufferingReader) Read(p []byte) (int, error) {
|
|
|
|
pos := 0
|
|
|
|
for {
|
|
|
|
n, err := r.r.Read(p[pos:])
|
|
|
|
pos += n
|
|
|
|
if err != nil {
|
|
|
|
if pos > 0 && errors.Is(err, io.EOF) {
|
|
|
|
return pos, nil
|
|
|
|
}
|
|
|
|
return pos, err
|
|
|
|
} else if pos >= len(p) {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return pos, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *Daemon) AddToStoreNar(ni *narinfo.NarInfo, r io.Reader) error {
|
|
|
|
d.mu.Lock()
|
|
|
|
defer d.mu.Unlock()
|
|
|
|
|
|
|
|
var preBuffer []byte
|
|
|
|
|
|
|
|
if d.peerMinorVersion >= 32 {
|
|
|
|
if _, err := d.writeOp(WopAddMultipleToStore); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing worker op WopAddMultipleToStore: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteUint64(0); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing repair (false): %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteUint64(1); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing dont-check-sigs (true): %w", err)
|
|
|
|
}
|
|
|
|
buf := new(bytes.Buffer)
|
|
|
|
bufs := &nixwire.Serializer{Writer: buf}
|
|
|
|
if _, err := bufs.WriteUint64(1); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing count (1): %w", err)
|
|
|
|
}
|
|
|
|
if err := d.writeNarInfo(ni, bufs); err != nil {
|
|
|
|
return fmt.Errorf("buffering NAR info: %w", err)
|
|
|
|
}
|
|
|
|
preBuffer = buf.Bytes()
|
|
|
|
} else {
|
|
|
|
if _, err := d.writeOp(WopAddToStoreNar); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing worker op WopAddToStoreNar: %w", err)
|
|
|
|
}
|
|
|
|
if err := d.writeNarInfo(ni, d.w); err != nil {
|
|
|
|
return fmt.Errorf("writing NAR info: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteUint64(0); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing repair (false): %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteUint64(1); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return fmt.Errorf("writing dont-check-sigs (true): %w", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if d.peerMinorVersion >= 23 {
|
|
|
|
// FramedSink
|
|
|
|
errCh := make(chan error)
|
|
|
|
mr := &bufferingReader{io.MultiReader(bytes.NewReader(preBuffer), r)}
|
2023-08-27 22:45:46 +00:00
|
|
|
w := &nixwire.Serializer{Writer: &hexDumpingWriter{enabled: false, w: d.w.Writer}}
|
2023-08-23 23:00:44 +00:00
|
|
|
go func() {
|
|
|
|
defer close(errCh)
|
|
|
|
buf := make([]byte, MaxBuf)
|
2023-08-27 22:45:46 +00:00
|
|
|
sofar := 0
|
2023-08-23 23:00:44 +00:00
|
|
|
for {
|
|
|
|
n, err := mr.Read(buf)
|
2023-08-27 22:45:46 +00:00
|
|
|
sofar += n
|
2023-08-23 23:00:44 +00:00
|
|
|
if errors.Is(err, io.EOF) {
|
|
|
|
break
|
|
|
|
} else if err != nil {
|
|
|
|
err = fmt.Errorf("reading: %w", err)
|
|
|
|
d.err = err
|
|
|
|
errCh <- err
|
|
|
|
return
|
|
|
|
}
|
2023-08-27 22:45:46 +00:00
|
|
|
if _, err := w.WriteBytes(buf[:n]); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
err = fmt.Errorf("writing payload: %w", err)
|
|
|
|
d.err = err
|
|
|
|
errCh <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
2023-08-27 22:45:46 +00:00
|
|
|
if _, err := w.WriteUint64(0); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
err = fmt.Errorf("sending framed EOF: %w", err)
|
|
|
|
d.err = err
|
|
|
|
errCh <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
if err := d.processStderr(nil, nil, nil); err != nil {
|
|
|
|
return fmt.Errorf("reading (framed) stderr from WopAddToStoreNar: %w", err)
|
|
|
|
}
|
|
|
|
return <-errCh
|
|
|
|
} else {
|
2023-08-27 22:45:46 +00:00
|
|
|
if err := d.processStderr(nil, nil, &bufferingReader{r}); err != nil {
|
2023-08-23 23:00:44 +00:00
|
|
|
return fmt.Errorf("reading stderr from WopAddToStoreNar: %w", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *Daemon) QueryValidDerivers(path string) ([]string, error) {
|
|
|
|
d.mu.Lock()
|
|
|
|
defer d.mu.Unlock()
|
|
|
|
|
|
|
|
if _, err := d.writeOp(WopQueryValidDerivers); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return nil, fmt.Errorf("writing worker op WopQueryValidDerivers: %w", err)
|
|
|
|
}
|
|
|
|
if _, err := d.w.WriteString(path); err != nil {
|
|
|
|
d.err = err
|
|
|
|
return nil, fmt.Errorf("writing store path: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := d.processStderr(nil, nil, nil); err != nil {
|
|
|
|
return nil, fmt.Errorf("reading stderr from WopQueryValidDerivers: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
drvPaths, err := d.r.ReadStrings()
|
|
|
|
if err != nil {
|
|
|
|
d.err = err
|
|
|
|
return nil, fmt.Errorf("reading deriver paths: %w", err)
|
|
|
|
}
|
|
|
|
return drvPaths, nil
|
|
|
|
}
|
|
|
|
|
2022-10-09 22:48:18 +00:00
|
|
|
func OpenDaemon(path string) (*Daemon, error) {
|
|
|
|
conn, err := net.Dial("unix", path)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("dialing %v: %w", path, err)
|
|
|
|
}
|
|
|
|
|
2023-08-27 22:45:46 +00:00
|
|
|
return OpenDaemonWithIOs("unix://"+path, conn, conn, conn)
|
2023-08-23 23:00:44 +00:00
|
|
|
}
|
2022-10-09 22:48:18 +00:00
|
|
|
|
2023-08-23 23:00:44 +00:00
|
|
|
type hexDumpingWriter struct {
|
|
|
|
w io.Writer
|
|
|
|
enabled bool
|
|
|
|
}
|
|
|
|
|
|
|
|
func (w *hexDumpingWriter) Write(p []byte) (int, error) {
|
|
|
|
n, err := w.w.Write(p)
|
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
|
|
|
if w.enabled {
|
|
|
|
log.Printf(">>\n>> %s", strings.TrimSuffix(strings.ReplaceAll(hex.Dump(p), "\n", "\n>> "), "\n>> "))
|
|
|
|
}
|
|
|
|
return n, nil
|
2023-08-17 23:48:07 +00:00
|
|
|
}
|
|
|
|
|
2023-08-27 22:45:46 +00:00
|
|
|
func OpenDaemonWithIOs(name string, r io.Reader, w io.Writer, c io.Closer) (*Daemon, error) {
|
2023-08-23 23:00:44 +00:00
|
|
|
d := &Daemon{
|
2023-08-27 22:45:46 +00:00
|
|
|
name: name,
|
2023-08-23 23:00:44 +00:00
|
|
|
conn: c,
|
|
|
|
w: &nixwire.Serializer{Writer: &hexDumpingWriter{w: w}},
|
|
|
|
r: &nixwire.Deserializer{Reader: r},
|
|
|
|
}
|
2023-08-17 23:48:07 +00:00
|
|
|
if err := d.hello(); err != nil {
|
|
|
|
d.Close()
|
|
|
|
return nil, fmt.Errorf("sending hello: %w", err)
|
|
|
|
}
|
|
|
|
|
2022-10-09 22:48:18 +00:00
|
|
|
return d, nil
|
|
|
|
}
|