func TestWait(t *testing.T) {
responseDur := ptypes.DurationProto(42 * time.Second)
responseAny, err := ptypes.MarshalAny(responseDur)
if err != nil {
t.Fatal(err)
}
s := &getterService{
results: []*pb.Operation{
{Name: "foo"},
{Name: "foo"},
{Name: "foo"},
{Name: "foo"},
{Name: "foo"},
{
Name: "foo",
Done: true,
Result: &pb.Operation_Response{
Response: responseAny,
},
},
},
}
op := &Operation{
c: s,
proto: &pb.Operation{Name: "foo"},
}
if op.Done() {
t.Fatal("operation should not have completed yet")
}
var resp duration.Duration
bo := gax.Backoff{
Initial: 1 * time.Second,
Max: 3 * time.Second,
}
if err := op.wait(context.Background(), &resp, &bo, s.sleeper()); err != nil {
t.Fatal(err)
}
if !proto.Equal(&resp, responseDur) {
t.Errorf("response, got %v, want %v", resp, responseDur)
}
if !op.Done() {
t.Errorf("operation should have completed")
}
maxWait := []time.Duration{
1 * time.Second,
2 * time.Second,
3 * time.Second,
3 * time.Second,
3 * time.Second,
}
for i := 0; i < len(s.getTimes)-1; i++ {
w := s.getTimes[i+1] - s.getTimes[i]
if mw := maxWait[i]; w > mw {
t.Errorf("backoff, waited %s, max %s", w, mw)
}
}
}
func fromHTTPRequest(r *HTTPRequest) *logtypepb.HttpRequest {
if r == nil {
return nil
}
if r.Request == nil {
panic("HTTPRequest must have a non-nil Request")
}
u := *r.Request.URL
u.Fragment = ""
pb := &logtypepb.HttpRequest{
RequestMethod: r.Request.Method,
RequestUrl: u.String(),
RequestSize: r.RequestSize,
Status: int32(r.Status),
ResponseSize: r.ResponseSize,
UserAgent: r.Request.UserAgent(),
RemoteIp: r.RemoteIP, // TODO(jba): attempt to parse http.Request.RemoteAddr?
Referer: r.Request.Referer(),
CacheHit: r.CacheHit,
CacheValidatedWithOriginServer: r.CacheValidatedWithOriginServer,
}
if r.Latency != 0 {
pb.Latency = ptypes.DurationProto(r.Latency)
}
return pb
}
func bestMomentInHistory() (*Operation, error) {
t, err := time.Parse("2006-01-02 15:04:05.999999999 -0700 MST", "2009-11-10 23:00:00 +0000 UTC")
if err != nil {
return nil, err
}
resp, err := ptypes.TimestampProto(t)
if err != nil {
return nil, err
}
respAny, err := ptypes.MarshalAny(resp)
if err != nil {
return nil, err
}
metaAny, err := ptypes.MarshalAny(ptypes.DurationProto(1 * time.Hour))
return &Operation{
proto: &pb.Operation{
Name: "best-moment",
Done: true,
Metadata: metaAny,
Result: &pb.Operation_Response{
Response: respAny,
},
},
}, err
}
func NewUnaryServerInterceptor(auth Authorizer, inst Instrumenter) grpc.UnaryServerInterceptor {
return func(
ctx context.Context,
in interface{},
info *grpc.UnaryServerInfo,
handler grpc.UnaryHandler,
) (interface{}, error) {
requester, ok := in.(interface {
GetRequest() *Request
})
req := requester.GetRequest()
if !ok || req == nil {
return nil, ErrInvalidRequest
}
if req.GetSource() == nil {
return nil, ErrInvalidRequest
}
s := strings.Split(info.FullMethod, "/")
if len(s) != 3 || s[0] != "" || s[1] == "" || s[2] == "" {
return nil, ErrInvalidRequest
}
req.Call = &Call{Service: s[1], Method: s[2]}
if err := auth.Authorize(ctx, req); err != nil {
inst.Instrument(&Event{Key: "request_unauthorized", Request: req, Error: err})
return nil, err
}
start := time.Now()
resp, err := handler(ctx, in)
if err != nil {
req.Call.Error = err.Error()
}
req.Call.Duration = ptypes.DurationProto(time.Since(start))
inst.Instrument(&Event{Key: "request_handled", Request: req, Error: err})
return resp, err
}
}