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() }