Exemplo n.º 1
0
func (r *Runtime) serveDial(req *dialMsg, conn circuit.Conn) {
	// Go guarantees the defer runs even if panic occurs
	defer conn.Close()

	expDial, _ := r.exportValues([]interface{}{PermRef(r.srv.Get(req.Service))}, conn.Addr())
	conn.Write(&returnMsg{Out: expDial})
	// Waiting for export acks not necessary since expDial is always a permptr.
}
Exemplo n.º 2
0
func (r *Runtime) serveCall(req *callMsg, conn circuit.Conn) {
	// Go guarantees the defer runs even if panic occurs
	defer conn.Close()

	h := r.exp.Lookup(req.ReceiverID)
	if h == nil {
		if err := conn.Write(&returnMsg{Err: NewError("reply: no exp handle")}); err != nil {
			// We need to distinguish between I/O errors and encoding errors.
			// An encoding error implies bad code (e.g. forgot to register a
			// type) and therefore is best handled by a panic. An I/O error is
			// an expected runtime condition, and thus we ignore it (as we are
			// on the server side).
			//
			// XXX: It should be Conn's responsibility to panic on encoding
			// errors.  For extra safety and convenience, we do something hacky
			// here in trying to guess if we got an encoding error, in case
			// Conn didn't throw a panic.
			if strings.HasPrefix(err.Error(), "gob") {
				panic(err)
			}
		}
		return
	}

	fn := h.Type.Func[req.FuncID]
	if fn == nil {
		conn.Write(&returnMsg{Err: NewError("no func")})
		return
	}

	in, err := r.importValues(req.In, fn.InTypes, conn.Addr(), true, nil)
	if err != nil {
		conn.Write(&returnMsg{Err: err})
		return
	}

	reply, err := call(h.Value, h.Type, req.FuncID, in)
	if err != nil {
		conn.Write(&returnMsg{Err: err})
		return
	}
	expReply, ptrPtr := r.exportValues(reply, conn.Addr())
	if err = conn.Write(&returnMsg{Out: expReply}); err != nil {
		// Gob encoding errors will often be the cause of this
		log.Printf("write error (%s)", err)
	}
	r.readGotPtrPtr(ptrPtr, conn)
}
Exemplo n.º 3
0
func (r *Runtime) serveGetPtr(req *getPtrMsg, conn circuit.Conn) {
	defer conn.Close()

	h := r.exp.Lookup(req.ID)
	if h == nil {
		if err := conn.Write(&returnMsg{Err: NewError("getPtr: no exp handle")}); err != nil {
			// See comment in serveCall.
			if strings.HasPrefix(err.Error(), "gob") {
				panic(err)
			}
		}
		return
	}
	expReply, _ := r.exportValues([]interface{}{r.Ref(h.Value.Interface())}, conn.Addr())
	conn.Write(&returnMsg{Out: expReply})
}
Exemplo n.º 4
0
func (r *Runtime) serveGo(req *goMsg, conn circuit.Conn) {

	// Go guarantees the defer runs even if panic occurs
	defer conn.Close()

	t := types.FuncTabl.TypeWithID(req.TypeID)
	if t == nil {
		conn.Write(&returnMsg{Err: NewError("reply: no func type")})
		return
	}
	// No need to acknowledge acquisition of re-exported ptrs since,
	// the caller is waiting for a return message anyway
	mainID := t.MainID()
	in, err := r.importValues(req.In, t.Func[mainID].InTypes, conn.Addr(), true, nil)
	if err != nil {
		conn.Write(&returnMsg{Err: err})
		return
	}

	// Allow registration of a main goroutine. Kill runtime if none registered.
	r.openDaemonizer()
	defer func() {
		if !r.closeDaemonizer() {
			// Potentially unnecessary hack to ensure that last message sent to
			// caller is received before we die
			time.Sleep(time.Second)

			os.Exit(0)
		}
	}()

	reply, err := call(t.Zero(), t, mainID, in)

	if err != nil {
		conn.Write(&returnMsg{Err: err})
		return
	}
	expReply, ptrPtr := r.exportValues(reply, conn.Addr())
	err = conn.Write(&returnMsg{Out: expReply})
	r.readGotPtrPtr(ptrPtr, conn)

	conn.Close()
}
Exemplo n.º 5
0
func (r *Runtime) serveDropPtr(q *dropPtrMsg, conn circuit.Conn) {
	// Go guarantees the defer runs even if panic occurs
	defer conn.Close()

	r.exp.Remove(q.ID, conn.Addr())
}