func (y YValve) Recv() (_ io.ReadCloser, err error) { r := y.X.Call("Recv") if err = errors.Unpack(r[1]); err != nil { return nil, err } return xio.NewYReadCloser(r[0]), nil }
func (y YValve) Send() (_ io.WriteCloser, err error) { r := y.X.Call("Send") if err = errors.Unpack(r[1]); err != nil { return nil, err } return xio.NewYWriteCloser(r[0]), nil }
func (y YServer) Profile(name string) (rc io.ReadCloser, err error) { r := y.X.Call("Profile", name) if err := errors.Unpack(r[1]); err != nil { return nil, err } return xio.NewYReadCloser(r[0]), nil }
func (y YCmd) Start() (stdin io.WriteCloser, stdout, stderr io.ReadCloser, err error) { r := y.Call("Start") err = errors.Unpack(r[3]) if err != nil { return nil, nil, nil, err } return xyio.NewYWriteCloser(r[0]), xyio.NewYReadCloser(r[1]), xyio.NewYReadCloser(r[2]), nil }
func (y YReader) Read(p []byte) (n int, err error) { r := y.Call("Read", len(p)) q, err := unpackBytes(r[0]), errors.Unpack(r[1]) if len(q) > len(p) { panic("corrupt i/o server") } copy(p, q) return len(q), err }
func (y YShell) Tail(name string, arg ...string) (stdin io.WriteCloser, stdout, stderr io.ReadCloser, err error) { ig := make([]interface{}, 0, len(arg)) for _, a := range arg { ig = append(ig, a) } r := y.Call("Tail", ig...) err = errors.Unpack(r[3]) if err != nil { return nil, nil, nil, err } return xyio.NewYWriteCloser(r[0]), xyio.NewYReadCloser(r[1]), xyio.NewYReadCloser(r[2]), nil }
func (y YReader) Read(p []byte) (n int, err error) { r := y.Call("Read", len(p)) q, err := unpackBytes(r[0]), errors.Unpack(r[1]) if len(q) > len(p) { panic("corrupt i/o server") } copy(p, q) if err != nil && err.Error() == "EOF" { err = io.EOF } return len(q), err }
func (y YTerminal) Make(kind string, arg interface{}) (yelm interface{}, err error) { r := y.X.Call("Make", kind, arg) if err = xerrors.Unpack(r[1]); err != nil { return nil, err } switch kind { case Chan: return valve.YValve{r[0].(circuit.X)}, nil case Proc: return proc.YProc{r[0].(circuit.X)}, nil } return nil, errors.New("element kind not supported") }
func (y YReader) Read(p []byte) (n int, err error) { defer func() { // println(fmt.Sprintf("yread n=%d err=%v r=%v", n, err, recover())) if r := recover(); r != nil { println(fmt.Sprintf("r=%v", r)) os.Exit(1) } }() r := y.Call("Read", len(p)) q, err := unpackBytes(r[0]), errors.Unpack(r[1]) if len(q) > len(p) { panic("corrupt i/o server") } copy(p, q) if err != nil && err.Error() == "EOF" { err = io.EOF } return len(q), err }
func (y YTerminal) Make(kind string, arg interface{}) (yelm interface{}, err error) { r := y.X.Call("Make", kind, arg) if err = xerrors.Unpack(r[1]); err != nil { return nil, err } switch kind { case Chan: return valve.YValve{r[0].(circuit.X)}, nil case Proc: return proc.YProc{r[0].(circuit.X)}, nil case Docker: return docker.YContainer{r[0].(circuit.X)}, nil case OnJoin: return pubsub.YSubscription{r[0].(circuit.X)}, nil case OnLeave: return pubsub.YSubscription{r[0].(circuit.X)}, nil } return nil, errors.New("element kind not supported") }
func (d *Dialer) auth(addr n.Addr, conn *blend.Conn) error { defer conn.Close() if err := conn.Write(&HelloMsg{ SourceAddr: d.dialback, TargetAddr: addr, }); err != nil { return err } msg, err := conn.Read() if err != nil { return err } switch q := msg.(type) { case *WelcomeMsg: return nil case *RejectMsg: return errors.NewError("dial rejected by remote (%s)", errors.Unpack(q.Err)) } return errors.NewError("unknown welcome response") }
func (y YNameserver) Set(rr string) error { r := y.X.Call("Set", rr) return errors.Unpack(r[0]) }
func (y YCmd) Run() error { return errors.Unpack(y.Call("Run")) }
func (y YCmd) Wait() error { return errors.Unpack(y.Call("Wait")) }
func (y YServer) Rejoin(addr string) error { return errors.Unpack(y.X.Call("Rejoin", addr)[0]) }
func unpack(stat Stat) Stat { stat.Exit = errors.Unpack(stat.Exit) return stat }
func (y YValve) Close() error { return errors.Unpack(y.X.Call("Close")[0]) }
func (y YProc) Wait() (Stat, error) { r := y.X.Call("Wait") return unpack(r[0].(Stat)), errors.Unpack(r[1]) }
func (y YCloser) Close() error { return errors.Unpack(y.Call("Close")[0]) }
func (y YWriter) Write(p []byte) (n int, err error) { r := y.Call("Write", p) return r[0].(int), errors.Unpack(r[1]) }
func (y YContainer) Signal(sig string) error { r := y.X.Call("Signal", sig) return errors.Unpack(r[0]) }
func (y YContainer) Peek() (stat *ds.Stat, err error) { r := y.X.Call("Peek") stat, _ = r[0].(*ds.Stat) return stat, errors.Unpack(r[1]) }