// Regenerate user's auth tokens. func Regenerate(c *client.Client, username string, all bool) (string, error) { var reqBody []byte var err error if all == true { reqBody, err = json.Marshal(api.AuthRegenerateRequest{All: all}) } else if username != "" { reqBody, err = json.Marshal(api.AuthRegenerateRequest{Name: username}) } if err != nil { return "", err } body, err := c.BasicRequest("POST", "/v1/auth/tokens/", reqBody) if err != nil { return "", err } if all == true { return "", nil } token := api.AuthRegenerateResponse{} if err = json.Unmarshal([]byte(body), &token); err != nil { return "", err } return token.Token, nil }
func (i *Incident) Get(w http.ResponseWriter, r *http.Request) { w.Header().Add("content-type", "application/json") vars := mux.Vars(r) id, ok := vars["id"] if !ok { http.Error(w, "Must append incident id", http.StatusBadRequest) return } index := i.pipeline.GetIndex() // if the id is "*", fetch all outstanding incidents if id == "*" { all := index.ListIncidents() all = reduceStatusAbove(event.WARNING, all) buff, err := json.Marshal(makeKV(all)) if err != nil { logrus.Error(err) http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Write(buff) return } // write out the found incident. The value will be null if nothing was found in := index.GetIncident([]byte(id)) buff, err := json.Marshal(in) if err != nil { logrus.Error(err) http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Write(buff) }
func (b *Broker) SendNoLog(resp Response) error { b.wLck.Lock() defer b.wLck.Unlock() if resp.Data == nil { resp.Data = M{} } s, err := json.Marshal(resp) if err != nil { // if there is a token, it means the client is waiting for a response // so respond with the json error. cause of json encode failure includes: non-utf8 string if resp.Token == "" { return err } s, err = json.Marshal(M{ "error": "margo broker: cannot encode json response: " + err.Error(), }) if err != nil { return err } } // the only expected write failure are due to broken pipes // which usually means the client has gone away so just ignore the error b.w.Write(s) b.w.Write([]byte{'\n'}) return nil }
func GetTagsListV2Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) { namespace := ctx.Params(":namespace") repository := ctx.Params(":repository") r := new(models.Repository) if has, _, err := r.Has(namespace, repository); err != nil || has == false { log.Error("[REGISTRY API V2] Repository not found: %v", repository) result, _ := json.Marshal(map[string]string{"message": "Repository not found"}) return http.StatusNotFound, result } data := map[string]interface{}{} tags := []string{} data["name"] = fmt.Sprintf("%s/%s", namespace, repository) for _, value := range r.Tags { t := new(models.Tag) if err := t.GetByKey(value); err != nil { log.Error("[REGISTRY API V2] Tag not found: %v", err.Error()) result, _ := json.Marshal(map[string]string{"message": "Tag not found"}) return http.StatusNotFound, result } tags = append(tags, t.Name) } data["tags"] = tags result, _ := json.Marshal(data) return http.StatusOK, result }
// writeSummaries retrieves status summaries from the supplied // NodeStatusRecorder and persists them to the cockroach data store. func (s *Server) writeSummaries() error { nodeStatus, storeStatuses := s.recorder.GetStatusSummaries() if nodeStatus != nil { key := keys.NodeStatusKey(int32(nodeStatus.Desc.NodeID)) if err := s.db.Put(key, nodeStatus); err != nil { return err } if log.V(1) { statusJSON, err := json.Marshal(nodeStatus) if err != nil { log.Errorf("error marshaling nodeStatus to json: %s", err) } log.Infof("node %d status: %s", nodeStatus.Desc.NodeID, statusJSON) } } for _, ss := range storeStatuses { key := keys.StoreStatusKey(int32(ss.Desc.StoreID)) if err := s.db.Put(key, &ss); err != nil { return err } if log.V(1) { statusJSON, err := json.Marshal(&ss) if err != nil { log.Errorf("error marshaling storeStatus to json: %s", err) } log.Infof("store %d status: %s", ss.Desc.StoreID, statusJSON) } } return nil }
// Tests config file with JSON contents that don't match our structure func (suite *ConfigTestSuite) Test_LoadConfig_GoodJson() { var testObj map[string]interface{} var testObjJSON []byte // TODO: Test that the config actually gets the values we expect? // Has all of our required fields, but no optional fields json.Unmarshal(suite.confStubBlob, &testObj) for i := range suite.nonRequiredFields { delete(testObj, suite.nonRequiredFields[i]) } testObjJSON, _ = json.Marshal(testObj) _, err := LoadConfig(testObjJSON) suite.Nil(err, "JSON with good values for our required fields but no optional fields should succeed") // Has all of our required fields, and all optional fields _, err = LoadConfig(suite.confStubBlob) suite.Nil(err, "JSON with all good values for required and optional fields should succeed") // Has null for optional fields json.Unmarshal(suite.confStubBlob, &testObj) for i := range suite.nonRequiredFields { testObj[suite.nonRequiredFields[i]] = nil } testObjJSON, _ = json.Marshal(testObj) _, err = LoadConfig(testObjJSON) suite.Nil(err, "JSON with null for optional values should succeed") }
func checkstatus(p *os.Process, pname string, timest string) bool { fmt.Println("checkstatus", pname, p) reportlog[timest]["status"] = pname + " running" reportlog[timest][pname+"start"] = time.Now().Format("20060102150405") liner, _ := json.Marshal(reportlog) ioutil.WriteFile("static/data/reportlog.json", liner, 0) pw, _ := p.Wait() fmt.Println("checkstatus over", p) fmt.Println("timest=", timest) reportlog[timest][pname+"stop"] = time.Now().Format("20060102150405") t1, _ := time.Parse("20060102150405", reportlog[timest][pname+"stop"]) t2, _ := time.Parse("20060102150405", reportlog[timest][pname+"start"]) reportlog[timest][pname+"time"] = strconv.Itoa(int(t1.Sub(t2)) / 1e9) fmt.Println("t1=", t1) fmt.Println("t2=", t2) fmt.Println("cost=", t1.Sub(t2)) status := pw.Success() if status == true { reportlog[timest]["status"] = pname + " success" fmt.Println("checkstatus over success ", pname, p) } else { reportlog[timest]["status"] = pname + " failed" fmt.Println("checkstatus over failed ", pname, p) } liner, _ = json.Marshal(reportlog) ioutil.WriteFile("static/data/reportlog.json", liner, 0) return status }
func generateReserveNodeWorkflow(uuid string) ([][]byte, []byte, error) { reserve := reserveNodeTask{} err := json.Unmarshal(reserveNodeTaskTemplate, &reserve) if err != nil { return nil, nil, fmt.Errorf("error unmarshalling reserve node task template: %s", err) } reserve.Name = fmt.Sprintf("%s.%s", reserve.Name, uuid) reserve.UnusedName = fmt.Sprintf("%s.%s", reserve.UnusedName, "UPLOADED_BY_RACKHD_CPI") reserveBytes, err := json.Marshal(reserve) if err != nil { return nil, nil, fmt.Errorf("error reserve provision node task template: %s", err) } w := reserveNodeWorkflow{} err = json.Unmarshal(reserveNodeWorkflowTemplate, &w) if err != nil { return nil, nil, fmt.Errorf("error unmarshalling reserve node workflow template: %s", err) } w.Name = fmt.Sprintf("%s.%s", w.Name, uuid) w.UnusedName = fmt.Sprintf("%s.%s", w.UnusedName, "UPLOADED_BY_RACKHD_CPI") w.Tasks[3].TaskName = fmt.Sprintf("%s.%s", w.Tasks[3].TaskName, uuid) wBytes, err := json.Marshal(w) if err != nil { return nil, nil, fmt.Errorf("error marshalling reserve node workflow template: %s", err) } return [][]byte{reserveBytes}, wBytes, nil }
// Implement json.Marshaler interface. func (self Week) MarshalJSON() ([]byte, error) { if int(self) == Last { return json.Marshal(map[string]interface{}{"week": "Last"}) } else { return json.Marshal(map[string]interface{}{"week": int(self)}) } }
func TestIncomingReplication(t *testing.T) { if testing.Short() { t.Skip() } rep := createMockupReplication() close(rep.(*mockupReplication).syncChan) //Make sure no deadlock occur ns := auth.NamespaceFrom("ns1") r := newInMemoryRegistry(nil, rep) assert.NotContains(t, r.(*inMemoryRegistry).namespaces, ns) inst := newServiceInstance("Calc1", "192.168.0.1", 9080) payload, _ := json.Marshal(inst) data, _ := json.Marshal(&replicatedMsg{RepType: REGISTER, Payload: payload}) rep.(*mockupReplication).NotifyChannel <- &replication.InMessage{cluster.MemberID("192.1.1.3:6100"), ns, data} catalog, err := r.GetCatalog(auth.NamespaceFrom("ns1")) // NOTICE, it may fail, since a race between the registry and the test... time.Sleep(time.Duration(5) * time.Second) assert.NoError(t, err) instances1, err1 := catalog.List("Calc1", protocolPredicate) assert.NoError(t, err1) assert.Len(t, instances1, 1) }
func testJSONEquality(actual, expected interface{}) { actualJSON, err := json.Marshal(actual) Expect(err).ToNot(HaveOccurred()) expectedJSON, err := json.Marshal(expected) Expect(err).ToNot(HaveOccurred()) Expect(actualJSON).To(MatchJSON(expectedJSON)) }
func (ctx *Context) generateAncestry(imageId string, parentId string) error { if parentId == "" { selfAncestryJson, err := json.Marshal([]string{imageId}) if err != nil { return err } if err := ctx.storage.PutContent(storage.ImageAncestryPath(imageId), selfAncestryJson); err != nil { return err } return nil } data, err := ctx.storage.GetContent(storage.ImageAncestryPath(parentId)) if err != nil { return err } var ancestry []string if err := json.Unmarshal(data, &ancestry); err != nil { return err } newAncestry := []string{imageId} newAncestry = append(newAncestry, ancestry...) data, err = json.Marshal(newAncestry) if err != nil { return err } ctx.storage.PutContent(storage.ImageAncestryPath(imageId), data) return nil }
//database checked func generateAddModule(id, userId, jwt string, officers, assistants map[string]bool, op *jsonpatch.Operation, params map[string]string) (*jsonpatch.CommandContainer, error) { if err := checkAuthorityAndValidatePatch(jsonpatch.ADD, op.Type, userId, officers); err != nil { log.Println("Patch not acceptable: ", err) return nil, err } value := op.Value.(map[string]interface{}) command := buildDefaultCommand("SELECT add_module(%v)", value["id"].(string), id, value["description"].(string), value["video_id"].(string), value["script_id"].(string), value["parents"]) command.AfterCallback = func(transaction, prev interface{}) (interface{}, error) { client := serviceclient.New("acl-service") entity := map[string]interface{}{ "id": value["id"].(string), "parent": id, } jsonEntity, _ := json.Marshal(entity) err := checkStatus(client.Post("/objects", "json", bytes.NewReader(jsonEntity), "Authorization", jwt)) if err != nil { log.Println("error while creating acl entry: ", err) return nil, err } if len(assistants) > 0 { assistantsString := "" for k, _ := range assistants { assistantsString = assistantsString + "&sid=" + k } assistantsString = strings.TrimLeft(assistantsString, "&") permissions, _ := json.Marshal(map[string]bool{"read_permission": true, "create_permission": true, "update_permission": false, "delete_permission": false}) return nil, checkStatus(client.Put(fmt.Sprintf("/objects/%s/permissions?%s", value["id"], assistantsString), "application/json", bytes.NewReader(permissions), "Authorization", jwt)) } return nil, nil } return command, nil }
func TestGetTimestampNewSnapshot(t *testing.T) { store := storage.NewMemStorage() crypto := signed.NewEd25519() snapshot := &data.SignedSnapshot{ Signed: data.Snapshot{ Expires: data.DefaultExpires(data.CanonicalSnapshotRole), }, } snapshot.Signed.Version = 0 snapJSON, _ := json.Marshal(snapshot) store.UpdateCurrent("gun", storage.MetaUpdate{Role: "snapshot", Version: 0, Data: snapJSON}) // create a key to be used by GetTimestamp _, err := GetOrCreateTimestampKey("gun", store, crypto, data.ED25519Key) assert.Nil(t, err, "GetKey errored") ts1, err := GetOrCreateTimestamp("gun", store, crypto) assert.Nil(t, err, "GetTimestamp errored") snapshot = &data.SignedSnapshot{ Signed: data.Snapshot{ Expires: data.DefaultExpires(data.CanonicalSnapshotRole), }, } snapshot.Signed.Version = 1 snapJSON, _ = json.Marshal(snapshot) store.UpdateCurrent("gun", storage.MetaUpdate{Role: "snapshot", Version: 1, Data: snapJSON}) ts2, err := GetOrCreateTimestamp("gun", store, crypto) assert.NoError(t, err, "GetTimestamp errored") assert.NotEqual(t, ts1, ts2, "Timestamp was not regenerated when snapshot changed") }
// MarshalJSON returns either the slug or id of the image. It returns the id // if the slug is empty. func (d DropletCreateImage) MarshalJSON() ([]byte, error) { if d.Slug != "" { return json.Marshal(d.Slug) } return json.Marshal(d.ID) }
// a json Key, and a json value func JsonInternalOutputProtocol(writer io.Writer) (*sync.WaitGroup, chan<- KeyValue) { w := bufio.NewWriter(writer) in := make(chan KeyValue, 100) tab := []byte("\t") newline := []byte("\n") var wg sync.WaitGroup wg.Add(1) go func() { for kv := range in { kBytes, err := json.Marshal(kv.Key) if err != nil { Counter("JsonInternalOutputProtocol", "unable to json encode key", 1) log.Printf("%s - failed encoding %v", err, kv.Key) continue } vBytes, err := json.Marshal(kv.Value) if err != nil { Counter("JsonInternalOutputProtocol", "unable to json encode value", 1) log.Printf("%s - failed encoding %v", err, kv.Value) continue } w.Write(kBytes) w.Write(tab) w.Write(vBytes) w.Write(newline) } w.Flush() wg.Done() }() return &wg, in }
// MarshalJSON returns either the fingerprint or id of the ssh key. It returns // the id if the fingerprint is empty. func (d DropletCreateSSHKey) MarshalJSON() ([]byte, error) { if d.Fingerprint != "" { return json.Marshal(d.Fingerprint) } return json.Marshal(d.ID) }
// Simple Wrapper for http handlers func makeHTTPHandler(handlerFunc restAPIFunc) http.HandlerFunc { // Create a closure and return an anonymous function return func(w http.ResponseWriter, r *http.Request) { // Call the handler resp, err := handlerFunc(r) if err != nil { // Log error log.Errorf("Handler for %s %s returned error: %s", r.Method, r.URL, err) if resp == nil { // Send HTTP response http.Error(w, err.Error(), http.StatusInternalServerError) } else { // Send HTTP response as Json content, err1 := json.Marshal(resp) if err1 != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.WriteHeader(http.StatusInternalServerError) w.Write(content) } } else { // Send HTTP response as Json content, err := json.Marshal(resp) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Write(content) } } }
/* "Fn::GetAtt" : []string{"ResName","AttrName"}, */ func TestExpand(t *testing.T) { for _, eachTest := range userdataPassingTests { testReader := strings.NewReader(eachTest.input) expandResult, expandResultErr := ConvertToTemplateExpression(testReader, conversionParams) if nil != expandResultErr { t.Errorf("%s (Input: %s)", expandResultErr, eachTest.input) } else { testOutput := map[string]interface{}{ "Fn::Join": []interface{}{ "", eachTest.output, }, } expectedResult, expectedResultErr := json.Marshal(testOutput) if nil != expectedResultErr { t.Error(expectedResultErr) } else { actualMarshal, actualMarshalErr := json.Marshal(expandResult) if nil != actualMarshalErr { t.Errorf("%s (Input: %s)", actualMarshalErr, eachTest.input) } else if string(expectedResult) != string(actualMarshal) { t.Errorf("Failed to validate\n") t.Errorf("\tEXPECTED: %s\n", string(expectedResult)) t.Errorf("\tACTUAL: %s\n", string(actualMarshal)) } else { t.Logf("Validated: %s == %s", string(expectedResult), string(actualMarshal)) } } } } }
// MarshalJSON marshal this to JSON func (s Schema) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(s.schemaProps) if err != nil { return nil, fmt.Errorf("schema props %v", err) } b2, err := json.Marshal(s.vendorExtensible) if err != nil { return nil, fmt.Errorf("vendor props %v", err) } b3, err := s.Ref.MarshalJSON() if err != nil { return nil, fmt.Errorf("ref prop %v", err) } b4, err := s.Schema.MarshalJSON() if err != nil { return nil, fmt.Errorf("schema prop %v", err) } b5, err := json.Marshal(s.swaggerSchemaProps) if err != nil { return nil, fmt.Errorf("common validations %v", err) } var b6 []byte if s.ExtraProps != nil { jj, err := json.Marshal(s.ExtraProps) if err != nil { return nil, fmt.Errorf("extra props %v", err) } b6 = jj } return swag.ConcatJSON(b1, b2, b3, b4, b5, b6), nil }
func GetManifestsV2Handler(ctx *macaron.Context, log *logs.BeeLogger) (int, []byte) { t := new(models.Tag) namespace := ctx.Params(":namespace") repository := ctx.Params(":repository") if err := t.Get(namespace, repository, ctx.Params(":tag")); err != nil { log.Error("[REGISTRY API V2] Manifest not found: %v", err.Error()) result, _ := json.Marshal(map[string]string{"message": "Manifest not found"}) return http.StatusNotFound, result } digest, err := utils.DigestManifest([]byte(t.Manifest)) if err != nil { log.Error("[REGISTRY API V2] Get manifest digest failed: %v", err.Error()) result, _ := json.Marshal(map[string]string{"message": "Get manifest digest failed"}) return http.StatusBadRequest, result } ctx.Resp.Header().Set("Content-Type", "application/json; charset=utf-8") ctx.Resp.Header().Set("Docker-Content-Digest", digest) ctx.Resp.Header().Set("Content-Length", fmt.Sprint(len(t.Manifest))) return http.StatusOK, []byte(t.Manifest) }
func TestAggStatsSampleJSON(t *testing.T) { a := NewAggStats(func() Aggregatable { return &BucketStats{} }) if a == nil { t.Errorf("Expected NewAggStats() to work") } s := &BucketStats{Ops: 10} for i := 0; i < 5; i++ { a.AddSample(s) } j0, err := json.Marshal(a.Levels[0]) if err != nil { t.Errorf("Expected json marshal to work, got: %v", err) } ja, err := json.Marshal(a) if err != nil { t.Errorf("Expected json marshal to work, got: %v", err) } if bytes.Index(ja, j0) <= 0 { t.Errorf("Expected json to be in the larger json, got: %v versus %v", j0, ja) } }
// MarshalJSON provides a custom Marshal method for Vin. func (v *Vin) MarshalJSON() ([]byte, error) { if v.IsCoinBase() { coinbaseStruct := struct { Coinbase string `json:"coinbase"` Sequence uint32 `json:"sequence"` }{ Coinbase: v.Coinbase, Sequence: v.Sequence, } return json.Marshal(coinbaseStruct) } txStruct := struct { Txid string `json:"txid"` Vout uint32 `json:"vout"` ScriptSig *ScriptSig `json:"scriptSig"` Sequence uint32 `json:"sequence"` }{ Txid: v.Txid, Vout: v.Vout, ScriptSig: v.ScriptSig, Sequence: v.Sequence, } return json.Marshal(txStruct) }
// MarshalJSON Marshal just the value of String func (nt NullTime) MarshalJSON() ([]byte, error) { if nt.Valid { return json.Marshal(nt.Time) } return json.Marshal(nil) }
func annotateRuntimeObject(t *testing.T, originalObj, currentObj runtime.Object, kind string) (string, []byte) { originalAccessor, err := meta.Accessor(originalObj) if err != nil { t.Fatal(err) } originalLabels := originalAccessor.GetLabels() originalLabels["DELETE_ME"] = "DELETE_ME" originalAccessor.SetLabels(originalLabels) original, err := json.Marshal(originalObj) if err != nil { t.Fatal(err) } currentAccessor, err := meta.Accessor(currentObj) if err != nil { t.Fatal(err) } currentAnnotations := currentAccessor.GetAnnotations() if currentAnnotations == nil { currentAnnotations = make(map[string]string) } currentAnnotations[annotations.LastAppliedConfigAnnotation] = string(original) currentAccessor.SetAnnotations(currentAnnotations) current, err := json.Marshal(currentObj) if err != nil { t.Fatal(err) } return currentAccessor.GetName(), current }
// qhEcho is an example query handler. It simply creates an // appropriate response and returns it. func qhEcho(args [][]byte) ([]byte, error) { // we have to have a subcommand! if len(args) == 0 { return qhErrNoSubCmd("echo") } // gin up a blank success reponse resp := qhStubResponse("echo", args) // the Data field of a QueryResponse contains the result of the // handler's processing. it is also of type json.RawMessage, which // means that it's a byteslice of pre-marshalled data. here, we // catenate together the non-subcmd args and use that. respstr := "" for _, x := range resp.Args { respstr = respstr + string(x) + " " } // marshal the string we built, and make it resp.Data if there's // no problem. data, err := json.Marshal(respstr) if err != nil { log.Println("echoQHandler: ", err) return nil, err } resp.Data = data // json.Marshal returns ([]byte, error) which satisfies our // signature, so just return that! return json.Marshal(resp) }
// Issue 5245. func TestEmbeddedBug(t *testing.T) { v := BugB{ BugA{"A"}, "B", } b, err := json.Marshal(v) if err != nil { t.Fatal("Marshal:", err) } want := `{"S":"B"}` got := string(b) if got != want { t.Fatalf("Marshal: got %s want %s", got, want) } // Now check that the duplicate field, S, does not appear. x := BugX{ A: 23, } b, err = json.Marshal(x) if err != nil { t.Fatal("Marshal:", err) } want = `{"A":23}` got = string(b) if got != want { t.Fatalf("Marshal: got %s want %s", got, want) } }
func (c *Client) authenticateChannel(params []byte, member *MemberData) (response []byte, err error) { channelName, socketId, err := parseAuthRequestParams(params) if err != nil { return } if err = validateSocketId(&socketId); err != nil { return } stringToSign := strings.Join([]string{socketId, channelName}, ":") var jsonUserData string if member != nil { var _jsonUserData []byte _jsonUserData, err = json.Marshal(member) if err != nil { return } jsonUserData = string(_jsonUserData) stringToSign = strings.Join([]string{stringToSign, jsonUserData}, ":") } _response := createAuthMap(c.Key, c.Secret, stringToSign) if member != nil { _response["channel_data"] = jsonUserData } response, err = json.Marshal(_response) return }
// What we're trying to do here is compare the JSON encoded values, but we can't // to a simple encode + string compare since JSON encoding is not ordered. So // what we do is JSON encode, then JSON decode into untyped maps, and then // finally do a recursive comparison. func compareObjects(t *testing.T, expected interface{}, actual interface{}) { expectedBytes, err := json.Marshal(expected) if err != nil { t.Fatal(err) return } actualBytes, err := json.Marshal(actual) if err != nil { t.Fatal(err) return } var expectedUntyped, actualUntyped map[string]interface{} err = json.Unmarshal(expectedBytes, &expectedUntyped) if err != nil { t.Fatal(err) return } err = json.Unmarshal(actualBytes, &actualUntyped) if err != nil { t.Fatal(err) return } if !reflect.DeepEqual(expectedUntyped, actualUntyped) { t.Fatalf("Expected %s, got %s", string(expectedBytes), string(actualBytes)) } }
// PatchNodeStatus patches node status. func PatchNodeStatus(c clientset.Interface, nodeName types.NodeName, oldNode *v1.Node, newNode *v1.Node) (*v1.Node, error) { oldData, err := json.Marshal(oldNode) if err != nil { return nil, fmt.Errorf("failed to marshal old node %#v for node %q: %v", oldNode, nodeName, err) } // Reset spec to make sure only patch for Status or ObjectMeta is generated. // Note that we don't reset ObjectMeta here, because: // 1. This aligns with Nodes().UpdateStatus(). // 2. Some component does use this to update node annotations. newNode.Spec = oldNode.Spec newData, err := json.Marshal(newNode) if err != nil { return nil, fmt.Errorf("failed to marshal new node %#v for node %q: %v", newNode, nodeName, err) } patchBytes, err := strategicpatch.CreateTwoWayMergePatch(oldData, newData, v1.Node{}) if err != nil { return nil, fmt.Errorf("failed to create patch for node %q: %v", nodeName, err) } updatedNode, err := c.Core().Nodes().Patch(string(nodeName), types.StrategicMergePatchType, patchBytes, "status") if err != nil { return nil, fmt.Errorf("failed to patch status %q for node %q: %v", patchBytes, nodeName, err) } return updatedNode, nil }