func (self *BuildState) parentChanged( parent dag.Node, pstate dag.NodeState, oldsig []byte) ( bool, error) { var cursig []byte var err error if !(pstate == dag.SOURCE || pstate == dag.BUILT || self.checkAll()) { // parent is an intermediate target that has not been built in // the current run. We don't want the expense of calling // Signature() for target nodes, because people don't normally // modify targets behind their build tool's back. But it might // have been modified by a previous build, in which case we'll // use the signature previously recorded for parent *as a // target*. This can still be fooled by modifying intermediate // targets behind Fubsy's back, but that's what --check-all is // for. precord, err := self.db.LookupNode(parent.Name()) if err != nil { return false, err } if precord != nil { cursig = precord.TargetSignature() } } if cursig == nil { cursig, err = parent.Signature() if err != nil { // This should not happen: parent should exist and be readable, // since we've already visited it earlier in the build and we // avoid looking at failed/tainted parents. return false, err } } changed := parent.Changed(cursig, oldsig) //log.Verbose("parent %s: oldsig=%v, cursig=%v, changed=%v", // parent, oldsig, cursig, changed) return changed, nil }
func (self *BuildState) recordNode(node dag.Node) error { log.Debug(log.BUILD, "recording successful build of %s %s", node.Typename(), node) sig, err := node.Signature() log.Debug(log.BUILD, "sig=%v, err=%v", sig, err) if err != nil { return fmt.Errorf("could not compute signature of target %s: %s", node, err) } record := db.NewBuildRecord() record.SetTargetSignature(sig) for _, parent := range self.graph.ParentNodes(node) { sig, err = parent.Signature() if err != nil { return err } record.AddParent(parent.Name(), sig) } err = self.db.WriteNode(node.Name(), record) if err != nil { return err } return nil }
// Inspect node and its parents to see if we need to build it. Return // build=true if we should build it, tainted=true if we should skip // building this node due to upstream failure. Return non-nil err if // there were unexpected node errors (error checking existence or // change status). func (self *BuildState) considerNode(node dag.Node) ( build bool, tainted bool, err error) { var exists, changed bool exists, err = node.Exists() // obvious rebuild (unless tainted) if err != nil { return } missing := !exists var record *db.BuildRecord if !missing { // skip DB lookup for missing nodes: the only thing that will // stop us from rebuilding them is a failed parent, and that // check comes later record, err = self.db.LookupNode(node.Name()) if err != nil { return } if record != nil { log.Debug(log.BUILD, "old parents of %s:", node) log.DebugDump(log.BUILD, record) } } build = missing parents := self.graph.ParentNodes(node) // Check if any of node's former parents have been removed. if !build && record != nil { build = parentsRemoved(parents, record) } for _, parent := range parents { pstate := parent.State() if pstate == dag.FAILED || pstate == dag.TAINTED { build = false tainted = true return // no further inspection required } var oldsig []byte if record != nil { oldsig = record.SourceSignature(parent.Name()) } if oldsig == nil { // New parent for this node: rebuild unless another // parent is failed/tainted. build = true } if build { continue } changed, err = self.parentChanged(parent, pstate, oldsig) if err != nil { return } if changed { // Do NOT return here: we need to continue inspecting // parents to make sure they don't taint this node with // upstream failure. build = true } } return }