code review 155730043: go.tools/dashboard/watcher: commit watcher rewrite

dashboard/watcher/watcher.go

+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
 // Command watcher watches the specified repository for new commits
 // and reports them to the build dashboard.
 package main
 
 import (
         "bytes"
         "encoding/json"
         "encoding/xml"
+        "errors"
         "flag"
         "fmt"
+        "io"
         "io/ioutil"
         "log"
         "net/http"
+        "net/url"
         "os"
         "os/exec"
+        "path"
         "path/filepath"
         "runtime"
         "strings"
         "time"
 )
 
 var (
-        pkgPath      = flag.String("pkg", "", "Package path (empty for main repo)")
-        repo         = flag.String("repo", "https://code.google.com/p/go", "Repository URL")
-        local        = flag.String("local", "", "Local repo (for testing only)")
-        dashboard    = flag.String("dash", "https://build.golang.org/", "Dashboard URL")
+        repoURL      = flag.String("repo", "https://code.google.com/p/go", "Repository URL")
+        dashboard    = flag.String("dash", "https://build.golang.org/", "Dashboard URL (must end in /)")
         keyFile      = flag.String("key", defaultKeyFile, "Build dashboard key file")
         pollInterval = flag.Duration("poll", 10*time.Second, "Remote repo poll interval")
 )
 
 var (
         defaultKeyFile = filepath.Join(homeDir(), ".gobuildkey")
-        dashboardStart = "" // we'll ignore commits before this hash
         dashboardKey   = ""
 )
 
+// The first main repo commit on the dashboard; ignore commits before this.
+// This is for the main Go repo only.
+const dashboardStart = "2f970046e1ba96f32de62f5639b7141cda2e977c"
+
 func main() {
         flag.Parse()
-        if *pkgPath == "" {
-                // We only started building the main repo at this hash.
-                dashboardStart = "2f970046e1ba96f32de62f5639b7141cda2e977c"
-        }
-        if err := run(); err != nil {
-                fmt.Fprintln(os.Stderr, err)
-                os.Exit(1)
-        }
-}
-
+
+        err := run()
+        fmt.Fprintln(os.Stderr, err)
+        os.Exit(1)
+}
+
+// run is a little wrapper so we can use defer and return to signal
+// errors. It should only return a non-nil error.
 func run() error {
+        if !strings.HasSuffix(*dashboard, "/") {
+                return errors.New("dashboard URL (-dashboard) must end in /")
+        }
+        if err := checkHgVersion(); err != nil {
+                return err
+        }
+
         if k, err := readKey(); err != nil {
                 return err
         } else {
                 dashboardKey = k
         }
 
-        var goroot string
-        if *local != "" {
-                goroot = *local
-        } else {
-                dir, err := ioutil.TempDir("", "watcher")
+        dir, err := ioutil.TempDir("", "watcher")
+        if err != nil {
+                return err
+        }
+        defer os.RemoveAll(dir)
+
+        errc := make(chan error)
+
+        go func() {
+                r, err := NewRepo(dir, *repoURL, "")
                 if err != nil {
+                        errc <- err
+                        return
+                }
+                errc <- r.Watch()
+        }()
+
+        subrepos, err := subrepoList()
+        if err != nil {
+                return err
+        }
+        for _, path := range subrepos {
+                go func(path string) {
+                        url := "https://" + path
+                        r, err := NewRepo(dir, url, path)
+                        if err != nil {
+                                errc <- err
+                                return
+                        }
+                        errc <- r.Watch()
+                }(path)
+        }
+
+        // Must be non-nil.
+        return <-errc
+}
+
+// Repo represents a repository to be watched.
+type Repo struct {
+        root     string             // on-disk location of the hg repo
+        path     string             // base import path for repo (blank for main repo)
+        commits  map[string]*Commit // keyed by full commit hash (40 lowercase hex digits)
+        branches map[string]*Branch // keyed by branch name, eg "release-branch.go1.3" (or empty for default)
+}
+
+// NewRepo checks out a new instance of the Mercurial repository
+// specified by url to a new directory inside dir.
+// The path argument is the base import path of the repository,
+// and should be empty for the main Go repo.
+func NewRepo(dir, url, path string) (*Repo, error) {
+        r := &Repo{
+                path: path,
+                root: filepath.Join(dir, filepath.Base(path)),
+        }
+
+        r.logf("cloning %v", url)
+        cmd := exec.Command("hg", "clone", url, r.root)
+        if out, err := cmd.CombinedOutput(); err != nil {
+                return nil, fmt.Errorf("%v\n\n%s", err, out)
+        }
+
+        r.logf("loading commit log")
+        if err := r.loadCommits(); err != nil {
+                return nil, err
+        }
+        if err := r.findBranches(); err != nil {
+                return nil, err
+        }
+
+        r.logf("found %v branches among %v commits\n", len(r.branches), len(r.commits))
+        return r, nil
+}
+
+// Watch continuously runs "hg pull" in the repo, checks for
+// new commits, and posts any new commits to the dashboard.
+// It only returns a non-nil error.
+func (r *Repo) Watch() error {
+        for {
+                if err := hgPull(r.root); err != nil {
                         return err
                 }
-                defer os.RemoveAll(dir)
-                goroot = filepath.Join(dir, "go")
-                cmd := exec.Command("hg", "clone", *repo, goroot)
-                if out, err := cmd.CombinedOutput(); err != nil {
-                        return fmt.Errorf("%v\n\n%s", err, out)
-                }
-        }
-
-        commits, err := allCommits(goroot)
-        if err != nil {
-                return err
-        }
-
-        branches := make(map[string]*Branch)
-        for _, c := range commits {
+                if err := r.update(); err != nil {
+                        return err
+                }
+                for _, b := range r.branches {
+                        if err := r.postNewCommits(b); err != nil {
+                                return err
+                        }
+                }
+                time.Sleep(*pollInterval)
+        }
+}
+
+func (r *Repo) logf(format string, args ...interface{}) {
+        p := "go"
+        if r.path != "" {
+                p = path.Base(r.path)
+        }
+        log.Printf(p+": "+format, args...)
+}
+
+// postNewCommits looks for unseen commits on the specified branch and
+// posts them to the dashboard.
+func (r *Repo) postNewCommits(b *Branch) error {
+        if b.Head == b.LastSeen {
+                return nil
+        }
+        c := b.LastSeen
+        if c == nil {
+                // Haven't seen any: find the commit that this branch forked from.
+                for c := b.Head; c.Branch == b.Name; c = c.parent {
+                }
+        }
+        // Add unseen commits on this branch, working forward from last seen.
+        for c.children != nil {
+                // Find the next commit on this branch.
+                var next *Commit
+                for _, c2 := range c.children {
+                        if c2.Branch != b.Name {
+                                continue
+                        }
+                        if next != nil {
+                                // Shouldn't happen, but be paranoid.
+                                return fmt.Errorf("found multiple children of %v on branch %q: %v and %v", c, b.Name, next, c2)
+                        }
+                        next = c2
+                }
+                if next == nil {
+                        // No more children on this branch, bail.
+                        break
+                }
+                // Found it.
+                c = next
+
+                if err := r.postCommit(c); err != nil {
+                        return err
+                }
+                b.LastSeen = c
+        }
+        return nil
+}
+
+// postCommit sends a commit to the build dashboard.
+func (r *Repo) postCommit(c *Commit) error {
+        r.logf("sending commit to dashboard: %v", c)
+
+        t, err := time.Parse(time.RFC3339, c.Date)
+        if err != nil {
+                return err
+        }
+        dc := struct {
+                PackagePath string // (empty for main repo commits)
+                Hash        string
+                ParentHash  string
+
+                User string
+                Desc string
+                Time time.Time
+
+                NeedsBenchmarking bool
+        }{
+                PackagePath: r.path,
+                Hash:        c.Hash,
+                ParentHash:  c.Parent,
+
+                User: c.Author,
+                Desc: c.Desc,
+                Time: t,
+
+                NeedsBenchmarking: c.NeedsBenchmarking(),
+        }
+        b, err := json.Marshal(dc)
+        if err != nil {
+                return err
+        }
+
+        u := *dashboard + "commit?version=2&key=" + dashboardKey
+        resp, err := http.Post(u, "text/json", bytes.NewReader(b))
+        if err != nil {
+                return err
+        }
+        if resp.StatusCode != 200 {
+                return fmt.Errorf("status: %v", resp.Status)
+        }
+        return nil
+}
+
+// loadCommits runs "hg log" and populates the Repo's commit map.
+func (r *Repo) loadCommits() error {
+        log, err := hgLog(r.root)
+        if err != nil {
+                return err
+        }
+        r.commits = make(map[string]*Commit)
+        for _, c := range log {
+                r.commits[c.Hash] = c
+        }
+        for _, c := range r.commits {
+                if p, ok := r.commits[c.Parent]; ok {
+                        c.parent = p
+                        p.children = append(p.children, c)
+                }
+        }
+        return nil
+}
+
+// findBranches finds branch heads in the Repo's commit map
+// and populates its branch map.
+func (r *Repo) findBranches() error {
+        r.branches = make(map[string]*Branch)
+        for _, c := range r.commits {
                 if c.children == nil {
                         if !validHead(c) {
                                 continue
                         }
-                        seen, err := lastSeen(commits, c.Hash)
+                        seen, err := r.lastSeen(c.Hash)
                         if err != nil {
                                 return err
                         }
                         b := &Branch{Name: c.Branch, Head: c, LastSeen: seen}
-                        branches[c.Branch] = b
-                        log.Printf("found branch: %v", b)
-                }
-        }
-        log.Printf("found %v branches among %v commits\n", len(branches), len(commits))
-
-        for {
-                if err := update(goroot, commits, branches); err != nil {
-                        return err
-                }
-                for _, b := range branches {
-                        if b.Head == b.LastSeen {
-                                continue
-                        }
-                        c := b.LastSeen
-                        if c == nil {
-                                // Haven't seen any: find the earliest commit on this branch.
-                                for c := b.Head; c.Branch == b.Name; c = c.parent {
-                                }
-                        }
-                        // Add unseen commits on this branch, working forward from last seen.
-                        for c.children != nil {
-                                var next *Commit
-                                for _, c2 := range c.children {
-                                        if c2.Branch != b.Name {
-                                                continue
-                                        }
-                                        if next != nil {
-                                                // Shouldn't happen, but be paranoid.
-                                                return fmt.Errorf("found multiple children on branch %q: %v and %v", b.Name, next, c2)
-                                        }
-                                        next = c2
-                                }
-                                if next == nil {
-                                        // Hit the head commit, nothing more to do.
-                                        continue
-                                }
-                                c = next
-
-                                if err := postCommit(c); err != nil {
-                                        return err
-                                }
-                                b.LastSeen = c
-                        }
-                }
-                time.Sleep(*pollInterval)
-        }
+                        r.branches[c.Branch] = b
+                        r.logf("found branch: %v", b)
+                }
+        }
+        return nil
 }
 
 // validHead reports whether the specified commit should be considered a branch
 // head. It considers pre-go1 branches and certain specific commits as invalid.
 func validHead(c *Commit) bool {
+        // Pre Go-1 releases branches are irrelevant.
         if strings.HasPrefix(c.Branch, "release-branch.r") {
-                return true
+                return false
         }
         // Not sure why these revisions have no child commits,
         // but they're old so let's just ignore them.
-        return c.Hash == "b59f4ff1b51094314f735a4d57a2b8f06cfadf15" ||
-                c.Hash == "fc75f13840b896e82b9fa6165cf705fbacaf019c"
+        if c.Hash == "b59f4ff1b51094314f735a4d57a2b8f06cfadf15" ||
+                c.Hash == "fc75f13840b896e82b9fa6165cf705fbacaf019c" {
+                return false
+        }
+        // All other branches are valid.
+        return true
+}
+
+// update runs "hg pull" in the specified reporoot,
+// looks for new commits and branches,
+// and updates the comits and branches maps.
+func (r *Repo) update() error {
+        // TODO(adg): detect new branches with "hg branches".
+
+        // Check each branch for new commits.
+        for _, b := range r.branches {
+
+                // Find all commits on this branch from known head.
+                // The logic of this function assumes that "hg log $HASH:"
+                // returns hashes in the order they were committed (parent first).
+                bname := b.Name
+                if bname == "" {
+                        bname = "default"
+                }
+                log, err := hgLog(r.root, "-r", b.Head.Hash+":", "-b", bname)
+                if err != nil {
+                        return err
+                }
+
+                // Add unknown commits to r.commits, and update branch head.
+                for _, c := range log {
+                        // Ignore if we already know this commit.
+                        if _, ok := r.commits[c.Hash]; ok {
+                                continue
+                        }
+                        r.logf("found new commit %v", c)
+
+                        // Sanity check that we're looking at a commit on this branch.
+                        if c.Branch != b.Name {
+                                return fmt.Errorf("hg log gave us a commit from wrong branch: want %q, got %q", b.Name, c.Branch)
+                        }
+
+                        // Find parent commit.
+                        p, ok := r.commits[c.Parent]
+                        if !ok {
+                                return fmt.Errorf("can't find parent hash %q for %v", c.Parent, c)
+                        }
+
+                        // Link parent and child Commits.
+                        c.parent = p
+                        p.children = append(p.children, c)
+
+                        // Update branch head.
+                        b.Head = c
+
+                        // Add new commit to map.
+                        r.commits[c.Hash] = c
+                }
+        }
+
+        return nil
 }
 
 // lastSeen finds the most recent commit the dashboard has seen,
-// starting at the specified head.
-func lastSeen(commits map[string]*Commit, head string) (*Commit, error) {
-        h, ok := commits[head]
+// starting at the specified head. If the dashboard hasn't seen
+// any of the commits from head to the beginning, it returns nil.
+func (r *Repo) lastSeen(head string) (*Commit, error) {
+        h, ok := r.commits[head]
         if !ok {
                 return nil, fmt.Errorf("lastSeen: can't find %q in commits", head)
         }
 
         var s []*Commit
         for c := h; c != nil; c = c.parent {
                 s = append(s, c)
-                if c.Hash == dashboardStart {
+                if r.path == "" && c.Hash == dashboardStart {
                         break
                 }
         }
 
         for _, c := range s {
-                u := *dashboard + "commit?hash=" + c.Hash
+                v := url.Values{"hash": {c.Hash}, "packagePath": {r.path}}
+                u := *dashboard + "commit?" + v.Encode()
                 r, err := http.Get(u)
                 if err != nil {
                         return nil, err
                 }
                 var resp struct {
                         Error string
                 }
                 err = json.NewDecoder(r.Body).Decode(&resp)
                 r.Body.Close()
                 if err != nil {
                         return nil, err
                 }
-                if resp.Error == "" {
+                switch resp.Error {
+                case "":
+                        // Found one.
                         return c, nil
-                }
-        }
+                case "Commit not found":
+                        // Commit not found, keep looking for earlier commits.
+                        continue
+                default:
+                        return nil, fmt.Errorf("dashboard: %v", resp.Error)
+                }
+        }
+
+        // Dashboard saw no commits.
         return nil, nil
-}
-
-// postCommit sends a commit to the build dashboard.
-func postCommit(c *Commit) error {
-        log.Printf("sending commit to dashboard: %v", c)
-
-        t, err := time.Parse(time.RFC3339, c.Date)
-        if err != nil {
-                return err
-        }
-        dc := struct {
-                PackagePath string // (empty for main repo commits)
-                Hash        string
-                ParentHash  string
-
-                User string
-                Desc string
-                Time time.Time
-
-                NeedsBenchmarking bool
-        }{
-                *pkgPath,
-                c.Hash,
-                c.Parent,
-                c.Author,
-                c.Desc,
-                t,
-                true,
-        }
-        b, err := json.Marshal(dc)
-        if err != nil {
-                return err
-        }
-
-        u := *dashboard + "commit?key=" + dashboardKey
-        r, err := http.Post(u, "text/json", bytes.NewReader(b))
-        if err != nil {
-                return err
-        }
-        if r.StatusCode != 200 {
-                return fmt.Errorf("status: %v", r.Status)
-        }
-        return nil
-}
-
-// allCommits runs "hg log" in goroot and returns a map of all its commits.
-func allCommits(goroot string) (map[string]*Commit, error) {
-        log, err := hgLog(goroot)
-        if err != nil {
-                return nil, err
-        }
-        commits := make(map[string]*Commit)
-        for _, c := range log {
-                commits[c.Hash] = c
-        }
-        for _, c := range commits {
-                if p, ok := commits[c.Parent]; ok {
-                        c.parent = p
-                        p.children = append(p.children, c)
-                }
-        }
-        return commits, nil
-}
-
-// update runs "hg pull" in the specified goroot,
-// looks for new commits and branches,
-// and updates the comits and branches maps.
-func update(goroot string, commits map[string]*Commit, branches map[string]*Branch) error {
-        if err := hgPull(goroot); err != nil {
-                return err
-        }
-
-        newBranches := make(map[string]*Branch)
-
-        // Check each branch for new commits.
-        for _, b := range branches {
-                // Find all commits from known head.
-                args := []string{"-r", b.Head.Hash + ":"}
-                if b.Name != "" {
-                        // Specify -b flag only for non-default branches.
-                        args = append(args, "-b", b.Name)
-                }
-                l, err := hgLog(goroot, args...)
-                if err != nil {
-                        return err
-                }
-
-                // Add unknown commits to commits, and create new branches.
-                for _, c := range l {
-                        if _, ok := commits[c.Hash]; ok {
-                                continue
-                        }
-
-                        log.Printf("found new commit %v", c)
-                        commits[c.Hash] = c
-
-                        p, ok := commits[c.Parent]
-                        if !ok {
-                                return fmt.Errorf("can't find parent hash %q for %v", c.Parent, c)
-                        }
-
-                        if c.Branch != b.Name {
-                                // The commit isn't on this branch.
-
-                                // If it's a new branch we've already seen this loop, update the new branch head.
-                                if b2, ok := newBranches[c.Branch]; ok {
-                                        log.Printf("branch %q head updated by: %v", c.Branch, c)
-                                        b2.Head = c
-                                        continue
-                                }
-
-                                // Sanity checks:
-                                if _, ok := branches[c.Branch]; ok && p.Branch != c.Branch {
-                                        // Shouldn't happen, but be paranoid about it.
-                                        return fmt.Errorf("commit branches into existing branch %q: %v", c.Branch, c)
-                                }
-                                if p.Branch == c.Branch {
-                                        // Shouldn't happen, but be paranoid.
-                                        return fmt.Errorf("commit on branch we haven't seen: %v", c)
-                                }
-
-                                // A new branch we haven't seen yet; add it.
-                                log.Printf("new branch %q created by %v", c.Branch, c)
-                                newBranches[c.Branch] = &Branch{Name: c.Branch, Head: c}
-                                continue
-                        }
-
-                        // Just a commit to a known branch, add it and update the branch head.
-                        c.parent = p
-                        p.children = append(p.children, c)
-                        b.Head = c
-                }
-        }
-
-        // Find latest dashboard commits for new branches.
-        for _, b := range newBranches {
-                seen, err := lastSeen(commits, b.Head.Hash)
-                if err != nil {
-                        return err
-                }
-                b.LastSeen = seen
-                branches[b.Name] = b
-        }
-
-        return nil
 }
 
 // hgLog runs "hg log" with the supplied arguments
 // and parses the output into Commit values.
 func hgLog(dir string, args ...string) ([]*Commit, error) {
         args = append([]string{"log", "--template", xmlLogTemplate}, args...)
         cmd := exec.Command("hg", args...)
         cmd.Dir = dir
         out, err := cmd.CombinedOutput()
         if err != nil {
                 return nil, err
         }
 
         // We have a commit with description that contains 0x1b byte.
         // Mercurial does not escape it, but xml.Unmarshal does not accept it.
         out = bytes.Replace(out, []byte{0x1b}, []byte{'?'}, -1)
 
+        xr := io.MultiReader(
+                strings.NewReader("<Top>"),
+                bytes.NewReader(out),
+                strings.NewReader("</Top>"),
+        )
         var logStruct struct {
                 Log []*Commit
         }
-        err = xml.Unmarshal([]byte("<Top>"+string(out)+"</Top>"), &logStruct)
+        err = xml.NewDecoder(xr).Decode(&logStruct)
         if err != nil {
                 return nil, err
         }
         return logStruct.Log, nil
 }
 
 // hgPull runs "hg pull" in the specified directory.
+// It tries three times, just in case it failed because of a transient error.
 func hgPull(dir string) error {
-        cmd := exec.Command("hg", "pull")
-        cmd.Dir = dir
-        if out, err := cmd.CombinedOutput(); err != nil {
-                return fmt.Errorf("%v\n\n%s", err, out)
-        }
-        return nil
+        var err error
+        for tries := 0; tries < 3; tries++ {
+                time.Sleep(time.Duration(tries) * 5 * time.Second) // Linear back-off.
+                cmd := exec.Command("hg", "pull")
+                cmd.Dir = dir
+                if out, e := cmd.CombinedOutput(); err != nil {
+                        e = fmt.Errorf("%v\n\n%s", e, out)
+                        log.Printf("hg pull error %v: %v", dir, e)
+                        if err == nil {
+                                err = e
+                        }
+                        continue
+                }
+                return nil
+        }
+        return err
 }
 
 // Branch represents a Mercurial branch.
 type Branch struct {
         Name     string
         Head     *Commit
         LastSeen *Commit // the last commit posted to the dashboard
 }
 
 func (b *Branch) String() string {
         return fmt.Sprintf("%q(Head: %v LastSeen: %v)", b.Name, b.Head, b.LastSeen)
 }
 
 // Commit represents a single Mercurial revision.
 type Commit struct {
         Hash   string
         Author string
         Date   string
-        Desc   string
+        Desc   string // Plain text, first linefeed-terminated line is a short description.
         Parent string
         Branch string
         Files  string
 
         // For walking the graph.
         parent   *Commit
         children []*Commit
 }
 
 func (c *Commit) String() string {
         return fmt.Sprintf("%v(%q)", c.Hash, strings.SplitN(c.Desc, "\n", 2)[0])
+}
+
+// NeedsBenchmarking reports whether the Commit needs benchmarking.
+func (c *Commit) NeedsBenchmarking() bool {
+        // Do not benchmark branch commits, they are usually not interesting
+        // and fall out of the trunk succession.
+        if c.Branch != "" {
+                return false
+        }
+        // Do not benchmark commits that do not touch source files (e.g. CONTRIBUTORS).
+        for _, f := range strings.Split(c.Files, " ") {
+                if (strings.HasPrefix(f, "include") || strings.HasPrefix(f, "src")) &&
+                        !strings.HasSuffix(f, "_test.go") && !strings.Contains(f, "testdata") {
+                        return true
+                }
+        }
+        return false
 }
 
 // xmlLogTemplate is a template to pass to Mercurial to make
 // hg log print the log in valid XML for parsing with xml.Unmarshal.
 // Can not escape branches and files, because it crashes python with:
 // AttributeError: 'NoneType' object has no attribute 'replace'
 const xmlLogTemplate = `
         <Log>
         <Hash>{node|escape}</Hash>
         <Parent>{p1node}</Parent>
@@ skipping 15 matching lines @@
         return os.Getenv("HOME")
 }
 
 func readKey() (string, error) {
         c, err := ioutil.ReadFile(*keyFile)
         if err != nil {
                 return "", err
         }
         return string(bytes.TrimSpace(bytes.SplitN(c, []byte("\n"), 2)[0])), nil
 }
+
+// subrepoList fetches a list of sub-repositories from the dashboard
+// and returns them as a slice of base import paths.
+// Eg, []string{"code.google.com/p/go.tools", "code.google.com/p/go.net"}.
+func subrepoList() ([]string, error) {
+        r, err := http.Get(*dashboard + "packages?kind=subrepo")
+        if err != nil {
+                return nil, err
+        }
+        var resp struct {
+                Response []struct {
+                        Path string
+                }
+                Error string
+        }
+        err = json.NewDecoder(r.Body).Decode(&resp)
+        r.Body.Close()
+        if err != nil {
+                return nil, err
+        }
+        if resp.Error != "" {
+                return nil, errors.New(resp.Error)
+        }
+        var pkgs []string
+        for _, r := range resp.Response {
+                pkgs = append(pkgs, r.Path)
+        }
+        return pkgs, nil
+}
+
+// checkHgVersion checks whether the installed version of hg supports the
+// template features we need. (May not be precise.)
+func checkHgVersion() error {
+        out, err := exec.Command("hg", "help", "templates").CombinedOutput()
+        if err != nil {
+                return fmt.Errorf("error running hg help templates: %v\n\n%s", err, out)
+        }
+        if !bytes.Contains(out, []byte("p1node")) {
+                return errors.New("installed hg doesn't support 'p1node' template keyword; please upgrade")
+        }
+        return nil
+}