func checkVersion(v semver.Version) {
fmt.Println("Current version is", cfg.version)
if v.LT(cfg.version) {
cfg.ForceCheck = true
log.Println("Checking entire tumblrblog due to new version.")
}
}
func MaybeUpdate(output io.Writer, githubOwner, githubRepo, binaryName, lastUpdatePath string, localVersion semver.Version) {
downloadBinary := binaryName + "-" + runtime.GOOS + "-" + runtime.GOARCH
updateLinkPrefix := "https://github.com/" + githubOwner + "/" + githubRepo + "/releases/tag/" + version.VersionPrefix
downloadLinkFormat := "https://github.com/" + githubOwner + "/" + githubRepo + "/releases/download/v%s/%s"
if !shouldCheckURLVersion(lastUpdatePath) {
return
}
latestVersion, err := getLatestVersionFromGitHub(githubOwner, githubRepo)
if err != nil {
glog.Errorln(err)
return
}
if localVersion.Compare(latestVersion) < 0 {
writeTimeToFile(lastUpdatePath, time.Now().UTC())
fmt.Fprintf(output, `There is a newer version of %s available. Do you want to
automatically update from %s%s to %s%s now? [y/N] `,
binaryName, version.VersionPrefix, localVersion, version.VersionPrefix, latestVersion)
var confirm string
fmt.Scanln(&confirm)
if confirm == "y" {
fmt.Printf("Updating to version %s\n", latestVersion)
updateBinary(latestVersion, downloadBinary, updateLinkPrefix, downloadLinkFormat)
return
}
fmt.Println("Skipping autoupdate")
}
}
func set(v semver.Version) {
err := ioutil.WriteFile(file, []byte(v.String()), os.ModeExclusive)
if err != nil {
fmt.Printf("Unable to write version file: %v", err)
os.Exit(3)
}
fmt.Printf("New version: %s", v)
}
func bump(p versionPart, v semver.Version) semver.Version {
switch p {
case major:
v.Major++
v.Minor = 0
v.Patch = 0
case minor:
v.Minor++
v.Patch = 0
case patch:
v.Patch++
}
return v
}
func (bump PreBump) Apply(v semver.Version) semver.Version {
if v.Pre == nil || v.Pre[0].VersionStr != bump.Pre {
v.Pre = []semver.PRVersion{
{VersionStr: bump.Pre},
{VersionNum: 1, IsNum: true},
}
} else {
v.Pre = []semver.PRVersion{
{VersionStr: bump.Pre},
{VersionNum: v.Pre[1].VersionNum + 1, IsNum: true},
}
}
return v
}
func (s *httpServer) performVersionNegotiatedRequestsToNSQD(
nsqlookupdAddrs []string, nsqdAddrs []string,
deprecatedURI string, v1URI string, queryString string) {
var err error
// get producer structs in one set of up-front requests
// so we can negotiate versions
//
// (this returns an empty list if there are no nsqlookupd configured)
producers, _ := lookupd.GetLookupdProducers(nsqlookupdAddrs)
for _, addr := range nsqdAddrs {
var nodeVer semver.Version
uri := deprecatedURI
producer := producerSearch(producers, addr)
if producer != nil {
nodeVer = producer.VersionObj
} else {
// we couldn't find the node in our list
// so ask it for a version directly
nodeVer, err = lookupd.GetVersion(addr)
if err != nil {
s.ctx.nsqadmin.logf("ERROR: failed to get nsqd %s version - %s", addr, err)
}
}
if nodeVer.NE(semver.Version{}) && nodeVer.GTE(v1EndpointVersion) {
uri = v1URI
}
endpoint := fmt.Sprintf("http://%s/%s?%s", addr, uri, queryString)
s.ctx.nsqadmin.logf("NSQD: querying %s", endpoint)
_, err := http_api.NegotiateV1("POST", endpoint, nil)
if err != nil {
s.ctx.nsqadmin.logf("ERROR: nsqd %s - %s", endpoint, err)
continue
}
}
}
// Ensures that the Docker daemon is in the desired container.
// Temporarily export the function to be used by dockershim.
// TODO(yujuhong): Move this function to dockershim once kubelet migrates to
// dockershim as the default.
func EnsureDockerInContainer(dockerVersion semver.Version, oomScoreAdj int, manager *fs.Manager) error {
type process struct{ name, file string }
dockerProcs := []process{{dockerProcessName, dockerPidFile}}
if dockerVersion.GTE(containerdVersion) {
dockerProcs = append(dockerProcs, process{containerdProcessName, containerdPidFile})
}
var errs []error
for _, proc := range dockerProcs {
pids, err := getPidsForProcess(proc.name, proc.file)
if err != nil {
errs = append(errs, fmt.Errorf("failed to get pids for %q: %v", proc.name, err))
continue
}
// Move if the pid is not already in the desired container.
for _, pid := range pids {
if err := ensureProcessInContainerWithOOMScore(pid, oomScoreAdj, manager); err != nil {
errs = append(errs, fmt.Errorf("errors moving %q pid: %v", proc.name, err))
}
}
}
return utilerrors.NewAggregate(errs)
}
// Create and initialize a new application. This is a front gate for
// the framework, since you should start by creating a new app struct.
// Every application should have a valid name (tag) and a version. So
// this function makes sure they have been passed and are all valid.
// Generally, you should not be creating more than one application.
func New(name, version string) *App {
var room = make(map[string]interface{})
const url = "https://github.com/ts33kr/boot"
const ename = "name is not of correct format"
const eversion = "version is not valid semver"
pattern := regexp.MustCompile("^[a-zA-Z0-9-_]+$")
var parsed semver.Version = semver.MustParse(version)
if !pattern.MatchString(name) {
panic(ename)
}
if parsed.Validate() != nil {
panic(eversion)
}
application := &App{Name: name, Version: parsed}
application.Storage = Storage{Container: room}
application.CronEngine = cron.New() // create CRON
application.Servers = make(map[string]*http.Server)
application.Reference = shortuuid.New() // V4
application.Providers = make([]*Provider, 0)
application.Services = make([]*Service, 0)
application.TimeLayout = time.RFC850
application.Namespace = url // set
return application // prepared app
}
func main() {
if len(os.Args) < 2 {
println("usage: " + os.Args[0] + " <source>")
os.Exit(1)
}
sources := os.Args[1]
var request models.OutRequest
err := json.NewDecoder(os.Stdin).Decode(&request)
if err != nil {
fatal("reading request", err)
}
driver, err := driver.FromSource(request.Source)
if err != nil {
fatal("constructing driver", err)
}
var newVersion semver.Version
if request.Params.File != "" {
versionFile, err := os.Open(filepath.Join(sources, request.Params.File))
if err != nil {
fatal("opening version file", err)
}
defer versionFile.Close()
var versionStr string
_, err = fmt.Fscanf(versionFile, "%s", &versionStr)
if err != nil {
fatal("reading version file", err)
}
newVersion, err = semver.Parse(versionStr)
if err != nil {
fatal("parsing version", err)
}
err = driver.Set(newVersion)
if err != nil {
fatal("setting version", err)
}
} else if request.Params.Bump != "" || request.Params.Pre != "" {
bump := version.BumpFromParams(request.Params.Bump, request.Params.Pre)
newVersion, err = driver.Bump(bump)
if err != nil {
fatal("bumping version", err)
}
} else {
println("no version bump specified")
os.Exit(1)
}
outVersion := models.Version{
Number: newVersion.String(),
}
json.NewEncoder(os.Stdout).Encode(models.OutResponse{
Version: outVersion,
Metadata: models.Metadata{
{"number", outVersion.Number},
},
})
}
func FixVersionClash(g *libkb.GlobalContext, cl libkb.CommandLine) (err error) {
var cli keybase1.ConfigClient
var ctlCli keybase1.CtlClient
var serviceConfig keybase1.Config
var socket net.Conn
g.Log.Debug("+ FixVersionClash")
defer func() {
if socket != nil {
socket.Close()
socket = nil
}
g.Log.Debug("- FixVersionClash -> %v", err)
}()
// Make our own stack here, circumventing all of our libraries, so
// as not to introduce any incompatibilities with earlier services
// (like 1.0.8)
socket, err = g.SocketInfo.DialSocket()
if err != nil {
g.Log.Debug("| Failed to DialSocket, but ignoring error: %s\n", err)
return nil
}
xp := libkb.NewTransportFromSocket(g, socket)
srv := rpc.NewServer(xp, libkb.WrapError)
gcli := rpc.NewClient(xp, libkb.ErrorUnwrapper{})
cli = keybase1.ConfigClient{Cli: gcli}
srv.Register(NewLogUIProtocol())
serviceConfig, err = cli.GetConfig(context.TODO(), 0)
if err != nil {
return err
}
g.Log.Debug("| Contacted service; got version: %s", serviceConfig.Version)
// We'll check and restart the service if there is a new version.
var semverClient, semverService semver.Version
cliVersion := libkb.VersionString()
if g.Env.GetRunMode() == libkb.DevelRunMode {
tmp := os.Getenv("KEYBASE_SET_VERSION")
if len(tmp) > 0 {
cliVersion = tmp
}
}
semverClient, err = semver.Make(cliVersion)
if err != nil {
return err
}
semverService, err = semver.Make(serviceConfig.Version)
if err != nil {
return err
}
g.Log.Debug("| version check %s v %s", semverClient, semverService)
if semverClient.EQ(semverService) {
g.Log.Debug("| versions check out")
return nil
} else if semverClient.LT(semverService) && semverClient.Major < semverService.Major {
return fmt.Errorf("Unexpected version clash; client is at v%s, which is significantly *less than* server at v%s",
semverClient, semverService)
}
g.Log.Warning("Restarting after upgrade; service is running v%s, while v%s is available",
semverService, semverClient)
origPid, err := getPid(g)
if err != nil {
g.Log.Warning("Failed to find pid for service: %v\n", err)
}
if serviceConfig.ForkType == keybase1.ForkType_LAUNCHD {
return restartLaunchdService(g, serviceConfig.Label, g.Env.GetServiceInfoPath())
}
ctlCli = keybase1.CtlClient{Cli: gcli}
err = ctlCli.Stop(context.TODO(), keybase1.StopArg{})
if err != nil && origPid >= 0 {
// A fallback approach. I haven't seen a need for it, but it can't really hurt.
// If we fail to restart via Stop() then revert to kill techniques.
g.Log.Warning("Error in Stopping %d via RPC: %v; trying fallback (kill via pidfile)", origPid, err)
time.Sleep(time.Second)
var newPid int
newPid, err = getPid(g)
if err != nil {
g.Log.Warning("No pid; shutdown must have worked (%v)", err)
} else if newPid != origPid {
g.Log.Warning("New service found with pid=%d; assuming restart", newPid)
return nil
} else {
if err = killPid(origPid); err != nil {
g.Log.Warning("Kill via pidfile failed: %v\n", err)
return err
}
g.Log.Warning("Successful kill() on pid=%d", origPid)
}
}
socket.Close()
socket = nil
time.Sleep(10 * time.Millisecond)
g.Log.Debug("Waiting for shutdown...")
time.Sleep(1 * time.Second)
if serviceConfig.ForkType == keybase1.ForkType_AUTO {
g.Log.Info("Restarting service...")
_, err = AutoForkServer(g, cl)
}
return err
}
package version_test
import (
"github.com/blang/semver"
"github.com/concourse/semver-resource/version"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("PreBump", func() {
var inputVersion semver.Version
var bump version.PreBump
var outputVersion semver.Version
BeforeEach(func() {
inputVersion = semver.Version{
Major: 1,
Minor: 2,
Patch: 3,
}
bump = version.PreBump{}
})
JustBeforeEach(func() {
outputVersion = bump.Apply(inputVersion)
})
Context("when the version is a prerelease", func() {
BeforeEach(func() {
inputVersion.Pre = []semver.PRVersion{
func (MinorBump) Apply(v semver.Version) semver.Version {
v.Minor++
v.Patch = 0
v.Pre = nil
return v
}
func FixVersionClash(g *libkb.GlobalContext, cl libkb.CommandLine) (err error) {
var cli keybase1.ConfigClient
var ctlCli keybase1.CtlClient
var serviceConfig keybase1.Config
g.Log.Debug("+ FixVersionClash")
defer func() {
g.Log.Debug("- FixVersionClash -> %v", err)
}()
cli, err = GetConfigClient(g)
if err != nil {
return err
}
serviceConfig, err = cli.GetConfig(context.TODO(), 0)
if err != nil {
return err
}
g.Log.Debug("| Contacted service; got version: %s", serviceConfig.Version)
// We'll check and restart the service if there is a new version.
var semverClient, semverService semver.Version
cliVersion := libkb.VersionString()
if g.Env.GetRunMode() == libkb.DevelRunMode {
tmp := os.Getenv("KEYBASE_SET_VERSION")
if len(tmp) > 0 {
cliVersion = tmp
}
}
semverClient, err = semver.Make(cliVersion)
if err != nil {
return err
}
semverService, err = semver.Make(serviceConfig.Version)
if err != nil {
return err
}
g.Log.Debug("| version check %s v %s", semverClient, semverService)
if semverClient.EQ(semverService) {
g.Log.Debug("| versions check out")
return nil
} else if semverClient.LT(semverService) {
return fmt.Errorf("Unexpected version clash; client is at v%s, which *less than* server at v%s",
semverClient, semverService)
}
g.Log.Warning("Restarting after upgrade; service is running v%s, while v%s is available",
semverService, semverClient)
ctlCli, err = GetCtlClient(g)
if err != nil {
return err
}
err = ctlCli.Stop(context.TODO(), 0)
if err != nil {
return err
}
time.Sleep(10 * time.Millisecond)
g.Log.Info("Waiting for shutdown...")
time.Sleep(1 * time.Second)
if serviceConfig.IsAutoForked {
g.Log.Info("Restarting service...")
_, err = AutoForkServer(g, cl)
}
return err
}
func (FinalBump) Apply(v semver.Version) semver.Version {
v.Pre = nil
return v
}
package version_test
import (
"fmt"
"github.com/blang/semver"
. "github.com/concourse/semver-resource/version"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("BumpForParams", func() {
var (
version semver.Version
bumpParam string
preParam string
)
BeforeEach(func() {
version = semver.Version{
Major: 1,
Minor: 2,
Patch: 3,
}
bumpParam = ""
preParam = ""
})
JustBeforeEach(func() {
func (PatchBump) Apply(v semver.Version) semver.Version {
v.Patch++
v.Pre = nil
return v
}