Fix walk graph to recurse correctly.

dm/appengine/deps/walk_graph.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package deps
 
 import (
         "fmt"
         "math"
         "sort"
@@ skipping 276 matching lines @@
                                                 logging.Fields{ek: err, "aid": aid}.Errorf(g, "error loading executions")
                                         } else {
                                                 dst.Partial.Executions = false
                                         }
                                         return err
                                 }
                         }
 
                         writeFwd := g.req.Include.FwdDeps
                         walkFwd := (g.req.Mode.Direction == dm.WalkGraphReq_Mode_BOTH ||
-                                g.req.Mode.Direction == dm.WalkGraphReq_Mode_FORWARDS)
+                                g.req.Mode.Direction == dm.WalkGraphReq_Mode_FORWARDS) && send != nil
                         loadFwd := writeFwd || walkFwd
 
                         if loadFwd {
                                 isAuthed := g.req.Auth != nil && g.req.Auth.Id.AttemptID().Equals(aid)
                                 subSend := func(aid *dm.Attempt_ID) error {
                                         return send(aid, isAuthed)
                                 }
                                 if writeFwd {
                                         dst.FwdDeps = dm.NewAttemptList(nil)
                                 }
                                 ch <- func() error {
                                         err := g.loadEdges(subSend, "FwdDep", akey, dst.FwdDeps, walkFwd)
                                         if err == nil && dst.Partial != nil {
                                                 dst.Partial.FwdDeps = false
                                         } else if err != nil {
                                                 logging.Fields{"aid": aid, ek: err}.Errorf(g, "while loading FwdDeps")
                                         }
                                         return err
                                 }
                         }
 
                         writeBack := g.req.Include.BackDeps
                         walkBack := (g.req.Mode.Direction == dm.WalkGraphReq_Mode_BOTH ||
-                                g.req.Mode.Direction == dm.WalkGraphReq_Mode_BACKWARDS)
+                                g.req.Mode.Direction == dm.WalkGraphReq_Mode_BACKWARDS) && send != nil
                         loadBack := writeBack || walkBack
 
                         if loadBack {
                                 if writeBack {
                                         dst.BackDeps = dm.NewAttemptList(nil)
                                 }
                                 subSend := func(aid *dm.Attempt_ID) error {
                                         return send(aid, false)
                                 }
                                 bdg := &model.BackDepGroup{Dependee: atmpt.ID}
@@ skipping 102 matching lines @@
 
         // nodeChan recieves attempt nodes to process. If it recieves the
         // `finishedJob` sentinel node, that indicates that an outstanding worker is
         // finished.
         nodeChan := make(chan *node, numWorkers)
         defer close(nodeChan)
 
         g := graphWalker{Context: c, req: req}
 
         sendNodeAuthed := func(depth int64) func(*dm.Attempt_ID, bool) error {
+                if req.Limit.MaxDepth != -1 && depth > req.Limit.MaxDepth {
+                        return nil
+                }
                 return func(aid *dm.Attempt_ID, isAuthed bool) error {
                         select {
                         case nodeChan <- &node{aid: aid, depth: depth, canSeeAttemptResult: isAuthed}:
                                 return nil
                         case <-c.Done():
                                 return c.Err()
                         }
                 }
         }
 
@@ skipping 79 matching lines @@
                                 }}
                                 if req.Include.Attempt.Result {
                                         atmpt.Partial.Result = dm.Attempt_Partial_NOT_LOADED
                                 }
 
                                 atmpt.NormalizePartial() // in case they're all false
                                 if req.Include.Attempt.Ids {
                                         atmpt.Id = n.aid
                                 }
                                 qst.Attempts[n.aid.Id] = atmpt
-                                if req.Limit.MaxDepth == -1 || n.depth < req.Limit.MaxDepth {
+                                if req.Limit.MaxDepth == -1 || n.depth <= req.Limit.MaxDepth {
                                         addJob(g.attemptLoader(n.aid, n.canSeeAttemptResult, atmpt,
                                                 sendNodeAuthed(n.depth+1)))
                                 }
                         }
                         // otherwise, we've dealt with this attempt before, so ignore it.
                 }
         }
 
         if c.Err() != nil {
                 rsp.HadMore = true
@@ skipping 37 matching lines @@
 func (d *deps) WalkGraph(c context.Context, req *dm.WalkGraphReq) (rsp *dm.GraphData, err error) {
         if req.Auth != nil {
                 logging.Fields{"execution": req.Auth.Id}.Debugf(c, "on behalf of")
         } else {
                 if err = canRead(c); err != nil {
                         return
                 }
         }
         return doGraphWalk(c, req)
 }