-
Notifications
You must be signed in to change notification settings - Fork 47
/
version.go
141 lines (130 loc) · 4.52 KB
/
version.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
// Copyright 2022 The CortexTheseus Authors
// This file is part of the CortexTheseus library.
//
// The CortexTheseus library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The CortexTheseus library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the CortexTheseus library. If not, see <http://www.gnu.org/licenses/>.
// Package version implements reading of build version information.
package version
import (
"fmt"
"runtime"
"runtime/debug"
"strings"
"github.com/CortexFoundation/CortexTheseus/params"
)
const ourPath = "github.com/CortexFoundation/CortexTheseus" // Path to our module
// These variables are set at build-time by the linker when the build is
// done by build/ci.go.
var gitCommit, gitDate string
// VCSInfo represents the git repository state.
type VCSInfo struct {
Commit string // head commit hash
Date string // commit time in YYYYMMDD format
Dirty bool
}
// VCS returns version control information of the current executable.
func VCS() (VCSInfo, bool) {
if gitCommit != "" {
// Use information set by the build script if present.
return VCSInfo{Commit: gitCommit, Date: gitDate}, true
}
if buildInfo, ok := debug.ReadBuildInfo(); ok {
if buildInfo.Main.Path == ourPath {
return buildInfoVCS(buildInfo)
}
}
return VCSInfo{}, false
}
// ClientName creates a software name/version identifier according to common
// conventions in the Cortex p2p network.
func ClientName(clientIdentifier string) string {
git, _ := VCS()
return fmt.Sprintf("%s/v%v/%v-%v/%v",
strings.Title(clientIdentifier),
params.VersionWithCommit(git.Commit, git.Date),
runtime.GOOS, runtime.GOARCH,
runtime.Version(),
)
}
// runtimeInfo returns build and platform information about the current binary.
//
// If the package that is currently executing is a prefixed by our CortexTheseus
// module path, it will print out commit and date VCS information. Otherwise,
// it will assume it's imported by a third-party and will return the imported
// version and whether it was replaced by another module.
func Info() (version, vcs string) {
version = params.VersionWithMeta
buildInfo, ok := debug.ReadBuildInfo()
if !ok {
return version, ""
}
version = versionInfo(buildInfo)
if status, ok := VCS(); ok {
modified := ""
if status.Dirty {
modified = " (dirty)"
}
commit := status.Commit
if len(commit) > 8 {
commit = commit[:8]
}
vcs = commit + "-" + status.Date + modified
}
return version, vcs
}
// versionInfo returns version information for the currently executing
// implementation.
//
// Depending on how the code is instantiated, it returns different amounts of
// information. If it is unable to determine which module is related to our
// package it falls back to the hardcoded values in the params package.
func versionInfo(info *debug.BuildInfo) string {
// If the main package is from our repo, prefix version with "geth".
if strings.HasPrefix(info.Path, ourPath) {
return fmt.Sprintf("geth %s", info.Main.Version)
}
// Not our main package, so explicitly print out the module path and
// version.
var version string
if info.Main.Path != "" && info.Main.Version != "" {
// These can be empty when invoked with "go run".
version = fmt.Sprintf("%s@%s ", info.Main.Path, info.Main.Version)
}
mod := findModule(info, ourPath)
if mod == nil {
// If our module path wasn't imported, it's unclear which
// version of our code they are running. Fallback to hardcoded
// version.
return version + fmt.Sprintf("geth %s", params.VersionWithMeta)
}
// Our package is a dependency for the main module. Return path and
// version data for both.
version += fmt.Sprintf("%s@%s", mod.Path, mod.Version)
if mod.Replace != nil {
// If our package was replaced by something else, also note that.
version += fmt.Sprintf(" (replaced by %s@%s)", mod.Replace.Path, mod.Replace.Version)
}
return version
}
// findModule returns the module at path.
func findModule(info *debug.BuildInfo, path string) *debug.Module {
if info.Path == ourPath {
return &info.Main
}
for _, mod := range info.Deps {
if mod.Path == path {
return mod
}
}
return nil
}