synapsecns/sanguine

package config

import (
    "fmt"
    "os"
    "time"

    "github.com/go-git/go-git/v5"
    "github.com/integralist/go-findroot/find"
)

// AppName is the application name.
const AppName = "Sanguine"

// DefaultVersion is the application version.
var DefaultVersion = "0.1.0"

// DefaultCommit is the default commit. Build info will attempt to replace
// with the current commit if not present.
var DefaultCommit = "none"

// DefaultDate when not passed in by the compiler.
var DefaultDate = time.Now().Format(time.RFC3339)

// DefaultMetricInterval is the metric interval.
const DefaultMetricInterval = time.Duration(1) * time.Minute

// VendorName is the vendor named used for versioning schemes that depend on a vendor name
// we use the github name for convince.
const VendorName = "synapsecns"

// BuildInfo will contains build info from https://goreleaser.com/cookbooks/using-main.version
// it is set at compile time by default. If it cannot be, we attempt to derive it at runtime.
type BuildInfo struct {
    version        string
    commit         string
    name           string
    date           string
    metricInterval time.Duration
}

// NewBuildInfo creates a build info struct from buildtime data
// it sets sensible defaults.
func NewBuildInfo(version, commit, name, date string) BuildInfo {
    if commit == DefaultCommit {
        commit = getCurrentCommit()
    }

    prefix := os.Getenv("NAME_PREFIX")
    if prefix != "" {
        name = fmt.Sprintf("%s-%s", prefix, name)
    }

    return BuildInfo{
        version: version,
        commit:  commit,
        name:    name,
        date:    date,
    }
}

// getCurrentCommit sets the commit from the local repo or uses default if not found.
func getCurrentCommit() string {
    root, err := find.Repo()
    // nothing we can do in this case, we'll use unknown
    if err != nil {
        return DefaultCommit
    }

    repo, err := git.PlainOpen(root.Path)
    if err != nil {
        return DefaultCommit
    }

    // get the current commit hash
    ref, err := repo.Head()
    if err != nil {
        return DefaultCommit
    }

    return ref.Strings()[0]
}

// Version of the build.
func (b BuildInfo) Version() string {
    return b.version
}

// Commit of the build.
func (b BuildInfo) Commit() string {
    return b.commit
}

// Name of the application.
func (b BuildInfo) Name() string {
    return b.name
}

// Date the application was built.
func (b BuildInfo) Date() string {
    return b.date
}

// MetricInterval the interval to record metrics at.
func (b BuildInfo) MetricInterval() time.Duration {
    return b.metricInterval
}

// VersionString pretty prints a version string with the info above.
func (b BuildInfo) VersionString() string {
    return fmt.Sprintf("%s: (commit: %s), commit (date: %s) \n", b.version, b.commit, b.date)
}