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])
}