func (routes *Routes) sendRegistrationResponse(w rest.ResponseWriter, r *rest.Request, sir *store.ServiceInstance) { routes.logger.WithFields(log.Fields{ "namespace": r.Env["REMOTE_USER"], }).Infof("Instance %s registered", sir) ttl := uint32(sir.TTL / time.Second) linksURL := r.BaseUrl() if middleware.IsUsingSecureConnection(r) { // request came in over a secure connection, continue using it linksURL.Scheme = "https" } links := BuildLinks(linksURL.String(), sir.ID) instance := &ServiceInstance{ ID: sir.ID, TTL: ttl, Links: links, } w.Header().Set("Location", links.Self) w.WriteHeader(http.StatusCreated) if err := w.WriteJson(instance); err != nil { routes.logger.WithFields(log.Fields{ "namespace": r.Env["REMOTE_USER"], "error": err, }).Warnf("Failed to write registration response for instance %s", sir) i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorEncoding) } }
func (api *EntityRestAPI) PostEntity(w rest.ResponseWriter, r *rest.Request) { entity := r.PathParam("entity") postData := map[string]interface{}{} if err := r.DecodeJsonPayload(&postData); err != nil { rest.Error(w, err.Error(), http.StatusInternalServerError) return } newId, err := api.em.PostEntity(entity, postData) if err != nil { rest.Error(w, err.Error(), http.StatusInternalServerError) return } insertedEntity, err := api.em.GetEntity(entity, strconv.FormatInt(newId, 10)) if err != nil { rest.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Location", fmt.Sprintf("%s/%d", entity, insertedEntity[api.em.GetIdColumn(entity)])) w.WriteHeader(http.StatusCreated) w.WriteJson(insertedEntity) }
func (a *Api) GetThumbnail(w rest.ResponseWriter, r *rest.Request) { name := r.PathParam("name") exists, data := a.binthumb.Retrieve(name) if exists { w.Header().Add("Content-Type", http.DetectContentType(data)) w.(http.ResponseWriter).Write(data) } else { _, data = a.binimage.Retrieve(name) datatype := http.DetectContentType(data) outbuf := bytes.NewBuffer([]byte{}) if datatype == "video/webm" { //v := nutil.GetVideoFrame(bytes.NewBuffer(data)) //i, _, _ = image.Decode(v) v := nutil.GetGifThumbnail(bytes.NewBuffer(data)) outbuf.ReadFrom(v) } else { i, _, _ := image.Decode(bytes.NewReader(data)) thmb := nutil.MakePropThumbnail(i, 314, 0) jpeg.Encode(outbuf, thmb, nil) } a.binthumb.Insert(name, outbuf.Bytes()) w.Header().Add("Content-Type", http.DetectContentType(outbuf.Bytes())) w.(http.ResponseWriter).Write(outbuf.Bytes()) } return }
// POST /releases.json func ReleasesPOST(w rest.ResponseWriter, r *rest.Request) { // Parse params from JSON val := new(struct { Method string `json:"method"` Params *simplejson.Json `json:"params"` }) decoder := json.NewDecoder(r.Body) err := decoder.Decode(&val) if err != nil { log.Println(err) } // Extract filters to apply to releases device, _ := val.Params.Get("device").String() channels, _ := val.Params.Get("channels").StringArray() // Prep JSON data data := map[string]interface{}{ "id": nil, "result": database.ReleasesListJSON(device, channels), "error": nil, } js, _ := json.Marshal(data) w.Header().Set("Content-Type", "application/json") w.WriteJson(js) }
func (r *Controller) toggleVIP(w rest.ResponseWriter, req *rest.Request) { w.Header().Set("Access-Control-Allow-Origin", "*") id, err := strconv.ParseUint(req.PathParam("id"), 10, 64) if err != nil { writeError(w, http.StatusBadRequest, err) return } r.log.Debug(fmt.Sprintf("Controller: REST: toggling a VIP (ID=%v)", id)) // Toggle VIP and get active server's IP and MAC addresses ip, mac, err := r.db.ToggleVIP(id) if err != nil { r.log.Info(fmt.Sprintf("Controller: REST: failed to query database: %v", err)) writeError(w, http.StatusInternalServerError, err) return } r.log.Debug(fmt.Sprintf("Controller: REST: toggled the VIP (ID=%v)", id)) for _, sw := range r.topo.Devices() { r.log.Info(fmt.Sprintf("Controller: REST: sending ARP announcement for a host (IP: %v, MAC: %v) via %v", ip, mac, sw.ID())) if err := sw.SendARPAnnouncement(ip, mac); err != nil { r.log.Err(fmt.Sprintf("Controller: REST: failed to send ARP announcement via %v: %v", sw.ID(), err)) continue } } w.WriteJson(&struct{}{}) }
func (r *Controller) removeNetwork(w rest.ResponseWriter, req *rest.Request) { w.Header().Set("Access-Control-Allow-Origin", "*") id, err := strconv.ParseUint(req.PathParam("id"), 10, 64) if err != nil { writeError(w, http.StatusBadRequest, err) return } r.log.Info(fmt.Sprintf("Controller: REST: removing network address whose id is %v", id)) ok, err := r.db.RemoveNetwork(id) if err != nil { r.log.Info(fmt.Sprintf("Controller: REST: failed to query database: %v", err)) writeError(w, http.StatusInternalServerError, err) return } if !ok { writeError(w, http.StatusNotFound, errors.New("unknown network ID")) return } r.log.Info(fmt.Sprintf("Controller: REST: removed network address whose id is %v", id)) for _, sw := range r.topo.Devices() { r.log.Info(fmt.Sprintf("Controller: REST: removing all flows from %v", sw.ID())) if err := sw.RemoveAllFlows(); err != nil { r.log.Warning(fmt.Sprintf("Controller: REST: failed to remove all flows on %v device: %v", sw.ID(), err)) continue } } w.WriteJson(&struct{}{}) }
func putDataE(w rest.ResponseWriter, r *rest.Request) { host := r.PathParam("host") if host == "" { rest.Error(w, "host is empty", 400) return } var jsonBody []byte jsonBody, _ = ioutil.ReadAll(r.Body) //if err != nil { log.Fatal(err) } simpleDataFromBody, err2 := simplejson.NewJson(jsonBody) if err2 != nil { rest.Error(w, "body (json) is empty", 400) return } if simpleDataFromBody.Get("message").MustString() == "" { rest.Error(w, "message for "+host+" is not valued", 400) return } if simpleDataFromBody.Get("details").MustString() == "" { rest.Error(w, "details for "+host+" is not valued", 400) return } CompteurE++ if CompteurE%2 == 0 { time.Sleep(500 * time.Millisecond) } defer r.Body.Close() w.Header().Set("X-Host", host) }
func HandleOwnIdentitiesPost(w rest.ResponseWriter, r *rest.Request) { fmt.Println("POST /identities") var identity Identity = Identity{} err := r.DecodeJsonPayload(&identity) if err != nil { w.Header().Set("Content-Type", "application/json; charset=UTF-8") w.WriteHeader(422) // unprocessable entity w.WriteJson("nop") } else { if identity.Hostname == "" { clientError(w, "Missing hostname") return } identity, err = FetchIdentity(identity.GetURI()) fmt.Println("ER", err) if err != nil { clientError(w, "Could not retrieve identity") return } _, err = db.C("identities").UpsertId(identity.ID, &identity) if err != nil { fmt.Println(err) internal(w, "Could not upsert identity") return } w.WriteJson(identity) } }
func (a *Api) GetImages(w rest.ResponseWriter, r *rest.Request) { w.Header().Add("Access-Control-Allow-Origin", "*") imgid, err := strconv.Atoi(r.PathParam("imgid")) if err != nil { log.Printf("api.GetIDstuffReverse: %s\n", err.Error()) rest.Error(w, "NYAN not found", 405) return } count, err := strconv.Atoi(r.PathParam("count")) if err != nil { log.Printf("api.GetIDstuffReverse: %s\n", err.Error()) rest.Error(w, "NYAN not found", 405) return } dbarray, err := a.meta.GetImagesRange(imgid, count) if err != nil { log.Printf("api.GetIDstuffReverse: %s\n", err.Error()) rest.Error(w, "NYAN not found", 405) return } imgreturn := convertCollection(dbarray) w.WriteJson( &IDTest{ Images: imgreturn, }) }
func GetNextCalendarEntry(w rest.ResponseWriter, r *rest.Request) { ctx := context.Background() deviceId := r.PathParam("id") ctx, err := calcom.GetNextGoogleCalendarEntry(ctx, deviceId) if err != nil { Log.Error(err.Error()) if err == calcom.ErrNoAppointments { rest.Error(w, "User has no upcomming events", NO_APPOINTMENT_CODE) } else { rest.Error(w, "Could not read calendar entries", ERROR_CODE) } return } answer, ok := calcom.FromContext(ctx) if !ok { /* should never be reached */ rest.Error(w, "Could not access next calendar entry", ERROR_CODE) return } w.Header().Set("Content-Type", CONTENT_TYPE) w.WriteJson(answer) }
// PostAddress register a new address func PostAddress(w rest.ResponseWriter, req *rest.Request) { address := addressStruct{} if err := req.DecodeJsonPayload(&address); err != nil { log.Printf(err.Error()) rest.Error(w, err.Error(), http.StatusInternalServerError) return } if address.Link == "" { err := errors.New("Link is empty") log.Printf(err.Error()) rest.Error(w, err.Error(), http.StatusInternalServerError) return } if address.IP == "" { err := errors.New("IP is empty") log.Printf(err.Error()) rest.Error(w, err.Error(), http.StatusInternalServerError) return } if _, _, err := net.ParseCIDR(address.IP); err != nil { log.Printf(err.Error()) rest.Error(w, err.Error(), http.StatusInternalServerError) return } err := db.Update(func(tx *bolt.Tx) (err error) { b := tx.Bucket([]byte(addressBucket)) if address.ID == "" { int, err := b.NextSequence() if err != nil { return err } address.ID = strconv.FormatUint(int, 10) } else { if _, err := strconv.ParseUint(address.ID, 10, 64); err == nil { return errors.New("ID is an integer") } if a := b.Get([]byte(address.ID)); a != nil { return errors.New("ID exists") } } data, err := json.Marshal(address) if err != nil { return } err = b.Put([]byte(address.ID), []byte(data)) return }) if err != nil { log.Printf(err.Error()) rest.Error(w, err.Error(), http.StatusInternalServerError) return } if err := setIP(address); err != nil { w.Header().Set("X-ERROR", err.Error()) } w.WriteJson(address) }
func refresh(w rest.ResponseWriter, r *rest.Request) { if newToken := fApi.api.RefreshUserSession(r.Header.Get(users.FANTAIL_SESSION_TOKEN)); newToken != "" { w.Header().Set(users.FANTAIL_SESSION_TOKEN, newToken) return } w.WriteHeader(http.StatusUnauthorized) return }
func GetDebug(w rest.ResponseWriter, r *rest.Request) { response := debugexport.NewDebugResposne(VERSION, clientconfig.Get()) if r.URL.Query().Get("inbrowser") != "true" { w.Header().Set("Content-Type", "application/octet-stream") w.Header().Set("Content-Disposition", fmt.Sprintf("inline; filename=alkasir-debuginfo\"%s.txt\"", response.Header.ID)) } _ = w.WriteJson(response) }
func (a *Api) GetItem(w rest.ResponseWriter, r *rest.Request) { name := r.PathParam("name") exists, data := a.binimage.Retrieve(name) if exists { w.Header().Add("Content-Type", http.DetectContentType(data)) w.(http.ResponseWriter).Write(data) return } return }
func (a *server) serveSecret(w rest.ResponseWriter, r *rest.Request) { // get the provider provider := a.builder.Build.SecretProviders[r.PathParam("type")] result, err := provider.GetSecret(r.PathParam("name")) if err != nil { rest.Error(w, err.Error(), http.StatusBadRequest) return } w.Header().Set("Content-Type", "text/plain") w.(http.ResponseWriter).Write([]byte(result)) }
func GetIDstuffReverse(w rest.ResponseWriter, r *rest.Request) { w.Header().Add("Access-Control-Allow-Origin", "*") var imgreturn []Image imgid, err := strconv.Atoi(r.PathParam("imgid")) if err != nil { log.Printf("api.GetIDstuffReverse: %s\n", err.Error()) rest.Error(w, "NYAN not found", 405) return } count, err := strconv.Atoi(r.PathParam("count")) if err != nil { log.Printf("api.GetIDstuffReverse: %s\n", err.Error()) rest.Error(w, "NYAN not found", 405) return } // alle parameter beisammen, call db foo dbase, err := Db.NewDb() if err != nil { log.Printf("api.GetIDstuffReverse: %s\n", err.Error()) rest.Error(w, "NAYN not found", 405) return } dbarray, err := dbase.GetPreviousImagesBefore(imgid, count) if err != nil { log.Printf("api.GetIDstuffReverse: %s\n", err.Error()) rest.Error(w, "NYAN not found", 405) return } for _, ele := range dbarray { var tmpImage Image tmpImage.ID = strconv.Itoa(ele.Id) tmpImage.Img = ele.Name tmpImage.Thumb = ele.Thumbnail tmpImage.Date = ele.Timestamp.Unix() tmpImage.Nick = ele.User tmpImage.Chan = ele.Channel tmpImage.Link = ele.Url tmpImage.Type = getFileType(ele.Name) imgreturn = append(imgreturn, tmpImage) } w.WriteJson( &IDTest{ ImageSrc: "http://aidskrebs.net/images/", ThumbSrc: "http://aidskrebs.net/images/", Images: imgreturn, }) }
func (r *Controller) listNetwork(w rest.ResponseWriter, req *rest.Request) { w.Header().Set("Access-Control-Allow-Origin", "*") networks, err := r.db.Networks() if err != nil { r.log.Info(fmt.Sprintf("Controller: REST: failed to query database: %v", err)) writeError(w, http.StatusInternalServerError, err) return } w.WriteJson(&struct { Networks []Network `json:"networks"` }{networks}) }
func (r *Controller) listSwitch(w rest.ResponseWriter, req *rest.Request) { w.Header().Set("Access-Control-Allow-Origin", "*") sw, err := r.db.Switches() if err != nil { r.log.Info(fmt.Sprintf("Controller: REST: failed to query database: %v", err)) writeError(w, http.StatusInternalServerError, err) return } w.WriteJson(&struct { Switches []Switch `json:"switches"` }{sw}) }
// PutAddress modify the existing address with the specified ID func PutAddress(w rest.ResponseWriter, req *rest.Request) { address := addressStruct{} if err := req.DecodeJsonPayload(&address); err != nil { log.Printf(err.Error()) rest.Error(w, err.Error(), http.StatusInternalServerError) return } address.ID = req.PathParam("address") // Removing the old interface address using netlink oldAddress := addressStruct{} err := db.View(func(tx *bolt.Tx) (err error) { tmp := tx.Bucket([]byte(addressBucket)).Get([]byte(address.ID)) if tmp != nil { err = json.Unmarshal(tmp, &oldAddress) if oldAddress != address { _ = deleteIP(oldAddress) } if err != nil { log.Printf(err.Error()) } } return }) if err != nil { log.Printf(err.Error()) } err = db.Update(func(tx *bolt.Tx) (err error) { b := tx.Bucket([]byte(addressBucket)) data, err := json.Marshal(address) if err != nil { return } err = b.Put([]byte(address.ID), []byte(data)) return }) if err != nil { log.Printf(err.Error()) rest.Error(w, err.Error(), http.StatusInternalServerError) return } if err = setIP(address); err != nil { w.Header().Set("X-ERROR", err.Error()) } w.WriteJson(address) }
func (a *AccountHandler) GetLatest(w rest.ResponseWriter, r *rest.Request) { code := r.PathParam("accountCode") latest := new(core.AccountSnapshotLatest) err := meddler.QueryRow(a.db, latest, "SELECT * FROM v_account_snapshot_latest WHERE account_code = $1", code) if err != nil { a.u.HandleError(err, w, r) return } path := fmt.Sprintf("/v1/accounts/%s/%s", code, latest.Latest.Format(time.RFC3339Nano)) url := r.UrlFor(path, make(map[string][]string)) w.Header().Add("Location", url.String()) w.WriteHeader(http.StatusSeeOther) }
func (r *Controller) listVIP(w rest.ResponseWriter, req *rest.Request) { w.Header().Set("Access-Control-Allow-Origin", "*") vip, err := r.db.VIPs() if err != nil { r.log.Info(fmt.Sprintf("Controller: REST: failed to query database: %v", err)) writeError(w, http.StatusInternalServerError, err) return } w.WriteJson(&struct { VIP []VIP `json:"vip"` }{vip}) }
/* Redirect the client to the link, OR return a 404 for an undefined target. */ func link_target(w rest.ResponseWriter, r *rest.Request) { arch := r.PathParam("arch") software := r.PathParam("software") version := r.PathParam("version") target := r.PathParam("target") target_file, found := get_target(arch, software, version, target) if found { target_link := get_link(cache_instance, db, target_file.Path) w.Header().Set("Location", target_link) w.WriteHeader(302) } else { w.WriteHeader(404) w.WriteJson(map[string]string{"error": "Target Not Found"}) } }
func (a *AccountHandler) GetAll(w rest.ResponseWriter, r *rest.Request) { err := RefreshIfNeeded(a.n, r, core.NtAccountRefresh, core.NtAccountFeedDone, 15*time.Second) if err != nil { a.u.HandleError(err, w, r) return } var accounts []*core.Account err = meddler.QueryAll(a.db, &accounts, "SELECT * FROM account") if err != nil { a.u.HandleError(err, w, r) return } w.Header().Add("Cache-Control", "private, max-age=60") w.WriteJson(&accounts) }
func (api *EntityRestAPI) GetAllEntities(w rest.ResponseWriter, r *rest.Request) { entity := r.PathParam("entity") qs := r.Request.URL.Query() limit, offset, orderBy, orderDir := qs.Get("_perPage"), qs.Get("_page"), qs.Get("_sortField"), qs.Get("_sortDir") qs.Del("_perPage") qs.Del("_page") qs.Del("_sortField") qs.Del("_sortDir") filterParams := make(map[string]string) // remaining GET parameters are used to filter the result for filterName, _ := range qs { filterParams[filterName] = qs.Get(filterName) } if offset == "" { offset = Offset } if limit == "" { limit = Limit } if orderBy == "" { orderBy = api.em.GetIdColumn(entity) } if orderDir == "" { orderDir = OrderDir } allResults, count, dbErr := api.em.GetEntities(entity, filterParams, limit, offset, orderBy, orderDir) if dbErr != nil { rest.Error(w, dbErr.Error(), http.StatusInternalServerError) return } w.Header().Set("Access-Control-Expose-Headers", "X-Total-Count") w.Header().Set("X-Total-Count", fmt.Sprintf("%d", count)) w.WriteJson(allResults) }
func GetJSONMessage(w rest.ResponseWriter, r *rest.Request) { time, err := strconv.Atoi(r.PathParam("time")) if err != nil { rest.Error(w, "Time has to be a number", 400) return } t := data.ClockInfoPackage{ Appointment: data.Appointment{ Time: int64(time), Name: "Meeting", Description: "Nöpe! Chuck Testa!", }, Timezone: "UTC+01:00", Apivers: 0, } w.Header().Set("Content-Type", "application/json; charset=utf-8") w.WriteJson(t) }
func (r *Controller) addNetwork(w rest.ResponseWriter, req *rest.Request) { w.Header().Set("Access-Control-Allow-Origin", "*") network := NetworkParam{} if err := req.DecodeJsonPayload(&network); err != nil { writeError(w, http.StatusBadRequest, err) return } if err := network.validate(); err != nil { writeError(w, http.StatusBadRequest, err) return } netMask := net.CIDRMask(int(network.Mask), 32) netAddr := net.ParseIP(network.Address) if netAddr == nil { panic("network.Address should be valid") } netAddr = netAddr.Mask(netMask) r.log.Info(fmt.Sprintf("Controller: REST: adding new network address: %v/%v", network.Address, network.Mask)) _, ok, err := r.db.Network(netAddr) if err != nil { r.log.Info(fmt.Sprintf("Controller: REST: failed to query database: %v", err)) writeError(w, http.StatusInternalServerError, err) return } if ok { r.log.Info(fmt.Sprintf("Controller: REST: duplicated network address: %v/%v", network.Address, network.Mask)) writeError(w, http.StatusConflict, errors.New("duplicated network address")) return } netID, err := r.db.AddNetwork(netAddr, netMask) if err != nil { r.log.Info(fmt.Sprintf("Controller: REST: failed to query database: %v", err)) writeError(w, http.StatusInternalServerError, err) return } r.log.Info(fmt.Sprintf("Controller: REST: added new network address: %v/%v", network.Address, network.Mask)) w.WriteJson(&struct { NetworkID uint64 `json:"network_id"` }{netID}) }
func (mw *Trace) handler(w rest.ResponseWriter, r *rest.Request, h rest.HandlerFunc) { index := mw.nextIndex() traceID := fmt.Sprintf("%s_%s_%d", mw.name, strconv.FormatInt(time.Now().UnixNano(), 10), index) r.Env[SdRequestID] = traceID for headerName, headerValue := range mw.headers { for _, value := range headerValue { w.Header().Set(headerName, value) } } w.Header().Set(SdRequestID, traceID) // Important, Need to call next handler last, since following middleware activate Write() to the connection, // requiring us to add the header at the pre stage of middleware chain h(w, r) }
func (a *Api) GetNewest(w rest.ResponseWriter, r *rest.Request) { w.Header().Add("Access-Control-Allow-Origin", "*") count, err := strconv.Atoi(r.PathParam("count")) if err != nil { rest.Error(w, "NYAN not found", 405) return } dbarray, err := a.meta.GetNewestImagesRange(count) if err != nil { log.Println(err.Error()) } imgreturn := convertCollection(dbarray) w.WriteJson( &IDTest{ Images: imgreturn, }) }
func (r *Controller) addVIP(w rest.ResponseWriter, req *rest.Request) { w.Header().Set("Access-Control-Allow-Origin", "*") vip := VIPParam{} if err := req.DecodeJsonPayload(&vip); err != nil { writeError(w, http.StatusBadRequest, err) return } if err := vip.validate(); err != nil { writeError(w, http.StatusBadRequest, err) return } r.log.Info(fmt.Sprintf("Controller: REST: adding a new VIP (%+v)", vip)) id, cidr, err := r.db.AddVIP(vip) if err != nil { r.log.Info(fmt.Sprintf("Controller: REST: failed to query database: %v", err)) writeError(w, http.StatusInternalServerError, err) return } r.log.Info(fmt.Sprintf("Controller: REST: added the new VIP (%+v)", vip)) w.WriteJson(&struct { ID uint64 `json:"vip_id"` }{id}) active, ok, err := r.db.Host(vip.ActiveHostID) if err != nil { r.log.Err(fmt.Sprintf("Controller: REST: failed to query active VIP host: %v", err)) return } if !ok { r.log.Err(fmt.Sprintf("Controller: REST: unknown active VIP host (ID=%v)", vip.ActiveHostID)) return } // Sends ARP announcement to all hosts to update their ARP caches (IP = VIP, MAC = Active's MAC) if err := r.sendARPAnnouncement(cidr, active.MAC); err != nil { r.log.Err(fmt.Sprintf("Controller: REST: failed to send ARP announcement for newly added VIP (ID=%v): %v", id, err)) return } }
func (r *Controller) addHost(w rest.ResponseWriter, req *rest.Request) { w.Header().Set("Access-Control-Allow-Origin", "*") host := HostParam{} if err := req.DecodeJsonPayload(&host); err != nil { writeError(w, http.StatusBadRequest, err) return } if err := host.validate(); err != nil { writeError(w, http.StatusBadRequest, err) return } r.log.Info(fmt.Sprintf("Controller: REST: adding a new host (%+v)", host)) hostID, err := r.db.AddHost(host) if err != nil { r.log.Info(fmt.Sprintf("Controller: REST: failed to query database: %v", err)) writeError(w, http.StatusInternalServerError, err) return } r.log.Info(fmt.Sprintf("Controller: REST: added the new host (%+v)", host)) w.WriteJson(&struct { HostID uint64 `json:"host_id"` }{hostID}) regHost, ok, err := r.db.Host(hostID) if err != nil { r.log.Err(fmt.Sprintf("Controller: REST: failed to query a registered host: %v", err)) return } if !ok { r.log.Err(fmt.Sprintf("Controller: REST: registered host (ID=%v) is vanished", hostID)) return } // Sends ARP announcement to all hosts to update their ARP caches if err := r.sendARPAnnouncement(regHost.IP, regHost.MAC); err != nil { r.log.Err(fmt.Sprintf("Controller: REST: failed to send ARP announcement for newly added host (ID=%v): %v", hostID, err)) return } }