// Call takes the object Id and an instance of ParamsType to create an
// object and place a call on its method. It then returns an instance
// of ResultType.
func (s *srvCaller) Call(objId string, arg reflect.Value) (reflect.Value, error) {
    objVal, err := s.creator(objId)
    if err != nil {
        return reflect.Value{}, err
    }
    return s.objMethod.Call(objVal, arg) // <1>
}

// Call calls the method with the given argument on the given receiver
// value. If the method does not return a value, the returned value
// will not be valid.
Call func(rcvr, arg reflect.Value) (reflect.Value, error)

func newMethod(m reflect.Method, receiverKind reflect.Kind) *ObjMethod {
    if m.PkgPath != "" {
        return nil
    }
    var p ObjMethod
    var assemble func(arg reflect.Value) []reflect.Value
    // N.B. The method type has the receiver as its first argument
    // unless the receiver is an interface.
    receiverArgCount := 1
    if receiverKind == reflect.Interface {
        receiverArgCount = 0
    }
    t := m.Type
    switch {                    // <1>
    case t.NumIn() == 0+receiverArgCount:
        // Method() ...
        assemble = func(arg reflect.Value) []reflect.Value {
            return nil
        }
    case t.NumIn() == 1+receiverArgCount:
        // Method(T) ...
        p.Params = t.In(receiverArgCount)
        assemble = func(arg reflect.Value) []reflect.Value {
            return []reflect.Value{arg}
        }
    default:
        return nil
    }

    switch {
    case t.NumOut() == 0:
        // Method(...)
        p.Call = func(rcvr, arg reflect.Value) (r reflect.Value, err error) {
            rcvr.Method(m.Index).Call(assemble(arg))
            return
        }
    case t.NumOut() == 1 && t.Out(0) == errorType:
        // Method(...) error
        p.Call = func(rcvr, arg reflect.Value) (r reflect.Value, err error) {
            out := rcvr.Method(m.Index).Call(assemble(arg))
            if !out[0].IsNil() {
                err = out[0].Interface().(error)
            }
            return
        }
    case t.NumOut() == 1:
        // Method(...) R
        p.Result = t.Out(0)
        p.Call = func(rcvr, arg reflect.Value) (reflect.Value, error) {
            out := rcvr.Method(m.Index).Call(assemble(arg))
            return out[0], nil
        }
    case t.NumOut() == 2 && t.Out(1) == errorType:
        // Method(...) (R, error)
        p.Result = t.Out(0)
        p.Call = func(rcvr, arg reflect.Value) (r reflect.Value, err error) {
            out := rcvr.Method(m.Index).Call(assemble(arg))
            r = out[0]
            if !out[1].IsNil() {
                err = out[1].Interface().(error)
            }
            return
        }
    default:
        return nil
    }
    // The parameters and return value must be of struct type.
    if p.Params != nil && p.Params.Kind() != reflect.Struct { // <2>
        return nil
    }
    if p.Result != nil && p.Result.Kind() != reflect.Struct {
        return nil
    }
    return &p
}

// Call takes the object Id and an instance of ParamsType to create an
// object and place a call on its method. It then returns an instance
// of ResultType.
func (s *srvCaller) Call(ctx context.Context, objId string, arg reflect.Value) (reflect.Value, error) {
    objVal, err := s.creator(objId)
    if err != nil {
        return reflect.Value{}, err
    }

    return s.objMethod.Call(objVal, ctx, arg)
}

func (conn *Conn) handleRequest(hdr *Header) error {
    serverSpan, err := opentracing.GlobalTracer().Join(
        "serverSpan",
        opentracing.TextMap,
        opentracing.HTTPHeaderTextMapCarrier(hdr),
    )
    if err != nil {
        // Create a root span if necessary
        serverSpan = opentracing.StartTrace("serverSpan")
    }

    var ctx context.Context
    ctx, _ = opentracing.ContextWithSpan(ctx, serverSpan)
    defer serverSpan.Finish()

    // TODO(perrito666) 2016-05-02 lp:1558657
    startTime := time.Now()
    req, err := conn.bindRequest(hdr)
    if err != nil {
        conn.notifier.ServerRequest(hdr, nil)
        if err := conn.readBody(nil, true); err != nil {
            return err
        }
        // We don't transform the error here. bindRequest will have
        // already transformed it and returned a zero req.
        return conn.writeErrorResponse(hdr, err, startTime)
    }
    var argp interface{}
    var arg reflect.Value
    if req.ParamsType() != nil {
        v := reflect.New(req.ParamsType())
        arg = v.Elem()
        argp = v.Interface()
    }
    if err := conn.readBody(argp, true); err != nil {
        conn.notifier.ServerRequest(hdr, nil)
        // If we get EOF, we know the connection is a
        // goner, so don't try to respond.
        if err == io.EOF || err == io.ErrUnexpectedEOF {
            return err
        }
        // An error reading the body often indicates bad
        // request parameters rather than an issue with
        // the connection itself, so we reply with an
        // error rather than tearing down the connection
        // unless it's obviously a connection issue.  If
        // the error is actually a framing or syntax
        // problem, then the next ReadHeader should pick
        // up the problem and abort.
        return conn.writeErrorResponse(hdr, req.transformErrors(err), startTime)
    }
    if req.ParamsType() != nil {
        conn.notifier.ServerRequest(hdr, arg.Interface())
    } else {
        conn.notifier.ServerRequest(hdr, struct{}{})
    }
    conn.mutex.Lock()
    closing := conn.closing
    if !closing {
        conn.srvPending.Add(1)
        go conn.runRequest(req, ctx, arg, startTime)
    }
    conn.mutex.Unlock()
    if closing {
        // We're closing down - no new requests may be initiated.
        return conn.writeErrorResponse(hdr, req.transformErrors(ErrShutdown), startTime)
    }
    return nil
}