func instanceFake(args []string, service *update.Service, out *tabwriter.Writer) int {
if instanceFlags.appId.Get() == nil || instanceFlags.groupId.Get() == nil {
return ERROR_USAGE
}
conf := &serverConfig{
server: globalFlags.Server,
}
for i := 0; i < instanceFlags.clientsPerApp; i++ {
c := &Client{
Id: fmt.Sprintf("{fake-client-%03d}", i),
SessionId: uuid.New(),
Version: instanceFlags.version,
AppId: instanceFlags.appId.String(),
Track: instanceFlags.groupId.String(),
config: conf,
errorRate: instanceFlags.errorRate,
pingsRemaining: instanceFlags.pingOnly,
forceUpdate: instanceFlags.forceUpdate,
}
go c.Loop(instanceFlags.minSleep, instanceFlags.maxSleep)
}
// run forever
wait := make(chan bool)
<-wait
return OK
}
func watch(args []string, service *update.Service, out *tabwriter.Writer) int {
tick := time.NewTicker(time.Second * time.Duration(watchFlags.interval))
server := globalFlags.Server
debug := globalFlags.Debug
version := watchFlags.version
if watchFlags.appId.Get() == nil || watchFlags.groupId.Get() == nil {
return ERROR_USAGE
}
if len(args) == 0 {
return ERROR_USAGE
}
appId := watchFlags.appId.String()
groupId := watchFlags.groupId.String()
clientId := watchFlags.clientId
if clientId == "" {
clientId = uuid.New()
}
// initial check
updateCheck, err := fetchUpdateCheck(server, appId, groupId, clientId, version, debug)
if err != nil {
fmt.Fprintf(os.Stderr, err.Error())
os.Exit(1)
}
runCmd(args[0], args[1:], appId, version, "", updateCheck)
for {
select {
case <-tick.C:
updateCheck, err := fetchUpdateCheck(server, appId, groupId, clientId, version, debug)
if err != nil {
log.Printf("warning: update check failed (%v)\n", err)
continue
}
if updateCheck.Status == "noupdate" {
continue
} else if updateCheck.Status == "error-version" {
continue
}
newVersion := updateCheck.Manifest.Version
if newVersion != version {
runCmd(args[0], args[1:], appId, newVersion, version, updateCheck)
}
version = newVersion
}
}
tick.Stop()
return OK
}
func fetchUpdateCheck(server string, appID string, groupID string, clientID string, version string, debug bool) (*omaha.UpdateCheck, error) {
client := &http.Client{}
// TODO: Fill out the OS field correctly based on /etc/os-release
request := omaha.NewRequest("lsb", "CoreOS", "", "")
app := request.AddApp(fmt.Sprintf("{%s}", appID), version)
app.AddUpdateCheck()
app.MachineID = clientID
app.BootId = uuid.New()
app.Track = groupID
event := app.AddEvent()
event.Type = "1"
event.Result = "0"
raw, err := xml.MarshalIndent(request, "", " ")
if err != nil {
fmt.Fprintln(os.Stderr, err)
return nil, err
}
if debug {
fmt.Fprintf(os.Stderr, "Request: %s%s\n", xml.Header, raw)
}
resp, err := client.Post(server+"/v1/update/", "text/xml", bytes.NewReader(raw))
if err != nil {
fmt.Fprintln(os.Stderr, err)
return nil, err
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Fprintln(os.Stderr, err)
return nil, err
}
if debug {
fmt.Fprintf(os.Stderr, "Response: %s%s\n", xml.Header, string(body))
}
oresp := &omaha.Response{}
err = xml.Unmarshal(body, oresp)
if err != nil {
fmt.Fprintln(os.Stderr, err)
return nil, err
}
return oresp.Apps[0].UpdateCheck, nil
}
func appCreate(args []string, service *update.Service, out *tabwriter.Writer) int {
if appFlags.appId.Get() == nil {
appFlags.appId.Set(uuid.New())
}
appReq := &update.AppInsertReq{
Id: appFlags.appId.String(),
Label: appFlags.label.String(),
Description: appFlags.description.String(),
}
call := service.App.Insert(appReq)
app, err := call.Do()
if err != nil {
log.Fatal(err)
}
fmt.Fprint(out, appHeader)
fmt.Fprintf(out, "%s", formatApp(app))
out.Flush()
return OK
}
func (c *Client) SetVersion(resp *omaha.Response) {
// A field can potentially be nil.
defer func() {
if err := recover(); err != nil {
c.Log("%s: error setting version: %v\n", c.Id, err)
}
}()
uc := resp.Apps[0].UpdateCheck
if uc.Status != "ok" {
c.Log("%s\n", uc.Status)
return
}
randFailRequest := func(eventType, eventResult string) (failed bool, err error) {
if rand.Intn(100) <= c.errorRate {
eventType = "3"
eventResult = "0"
failed = true
}
_, err = c.MakeRequest(eventType, eventResult, false, false)
return
}
requests := [][]string{
[]string{"13", "1"}, // downloading
[]string{"14", "1"}, // downloaded
[]string{"3", "1"}, // installed
}
for i, r := range requests {
if i > 0 {
time.Sleep(1 * time.Second)
}
failed, err := randFailRequest(r[0], r[1])
if failed {
log.Printf("failed to update in eventType: %s, eventResult: %s. Retrying.", r[0], r[1])
time.Sleep(time.Second * time.Duration(instanceFlags.minSleep))
c.MakeRequest(r[0], r[1], false, false)
return
}
if err != nil {
log.Println(err)
return
}
}
// simulate reboot lock for a while
for c.pingsRemaining > 0 {
c.MakeRequest("", "", false, true)
c.pingsRemaining--
time.Sleep(1 * time.Second)
}
c.Log("updated from %s to %s\n", c.Version, uc.Manifest.Version)
c.Version = uc.Manifest.Version
_, err := c.MakeRequest("3", "2", false, false) // Send complete with new version.
if err != nil {
log.Println(err)
}
c.SessionId = uuid.New()
}