Exemple #1
0
// Receive decodes each response result into result and calls f with the result's
// id. If a response error was received, result will not be touched and err will
// be populated for f. Likewise, on the end of a streaming call, result will not
// be touched and success will be true for the call to f.
func (r *PipeReader) Receive(result interface{}, f func(id []byte, err error, success bool) bool) error {
	for {
		var resp protocol.Response
		if err := r.dec.Decode(&resp); err == io.EOF {
			break
		} else if err != nil {
			return err
		} else if err := protocol.CheckID(resp.ID); err != nil {
			return err
		}

		if resp.Error == nil && !resp.Success {
			if err := json.Unmarshal(resp.Result, result); err != nil {
				return fmt.Errorf("error unmarshalling result: %v", err)
			}
		}

		var respErr error
		if resp.Error != nil {
			// this is due to Go's handling of nil values with interface types
			respErr = resp.Error
		}

		if !f(resp.ID, respErr, resp.Success) {
			break
		}
	}

	return nil
}
func (e Endpoint) handleRequest(ctx Context, de *json.Decoder, en *json.Encoder) (err error) {
	var req protocol.Request

	wr := newResponseWriter(&req, en)
	defer func() {
		// On a panic, write error response
		if e := recover(); e != nil {
			switch e := e.(type) {
			case *protocol.Error:
				err = wr.pError(e)
			case error:
				err = wr.Error(protocol.ErrorInternal, e.Error())
			default:
				err = wr.Error(protocol.ErrorInternal, fmt.Sprintf("%+v", e))
			}
		}
	}()

	// Decode request
	if err := de.Decode(&req); err == io.EOF {
		return err
	} else if err != nil {
		if e := wr.Error(protocol.ErrorParsing, fmt.Sprintf("error decoding JSON: %v", err)); e != nil {
			return fmt.Errorf("failed to write error response for %v: %v", err, e)
		}
		return err
	}

	// Validate request
	if err := protocol.CheckID(req.ID); err != nil {
		return wr.Error(protocol.ErrorInvalidRequest, err.Error())
	} else if req.Version != protocol.Version2 && req.Version != protocol.Version2Streaming {
		return wr.Error(protocol.ErrorInvalidRequest, fmt.Sprintf("invalid protocol version: %q", req.Version))
	}

	serviceName, methodName, err := parseServiceMethod(req.Method)
	if err != nil {
		return wr.Error(protocol.ErrorMethodNotFound,
			fmt.Sprintf("Unknown method name format: %q", req.Method))
	}

	// Handle builtin /ServerInfo service
	if serviceName == serverInfoService {
		req.Version = protocol.Version2 // downgrade version for ServerInfo methods
		if methodName != listMethod {
			return wr.Error(protocol.ErrorMethodNotFound,
				fmt.Sprintf("%q method not found in builtin service %q", methodName, serverInfoService))
		}

		spec, err := e.serviceList()
		if err != nil {
			panic(err) // shouldn't happen, internal server error
		}

		return wr.Result(spec)
	}

	// Resolve method
	method, err := e.Resolve(serviceName, methodName)
	if err != nil {
		return wr.Error(protocol.ErrorMethodNotFound,
			fmt.Sprintf("Method not found: /%s/%s", serviceName, methodName))
	}

	if !method.Stream {
		// Ensure downgraded version if method returns a single result
		req.Version = protocol.Version2
	}

	// Construct method output handler
	var (
		results [][]byte // For Version2 array result
		out     func(result []byte)
		outErr  error
	)
	switch req.Version {
	case protocol.Version2:
		out = func(result []byte) {
			results = append(results, result)
		}
	case protocol.Version2Streaming:
		out = func(result []byte) {
			if outErr != nil {
				return
			}
			outErr = wr.Result(result)
		}
	default:
		panic(fmt.Errorf("Unhandled version outputs: %q", req.Version))
	}

	// Invoke method with params
	err = method.Invoke(ctx, req.Params, out)
	if outErr != nil {
		panic(outErr)
	}
	if err != nil {
		switch err := err.(type) {
		case *protocol.Error:
			return wr.pError(err)
		default:
			return wr.Error(protocol.ErrorApplication, err.Error())
		}
	}

	switch req.Version {
	case protocol.Version2:
		if method.Stream {
			// If the client requested V2, but the method is streaming, we must
			// collect the results into a JSON array.
			arry := append(append([]byte("["), bytes.Join(results, []byte(","))...), []byte("]")...)
			return wr.Result(arry)
		} else if len(results) == 1 {
			// If the client requested V2 and the method is non-streaming, we just
			// return the result.
			return wr.Result(results[0])
		} else {
			// This shouldn't happen due to the way method registration works; a
			// non-streaming method MUST return a single result.
			log.Fatalf("Found non-singleton result for non-stream method: %v", results)
		}
	case protocol.Version2Streaming:
		// We already wrote the results, just end the stream.
		return wr.Success()
	default:
		// This case should never happen if we've correctly handled all protocol
		// versions.
		panic(fmt.Errorf("Unexpected protocol version: %q", req.Version))
	}

	panic("unexpected end of request handler")
}