dpVersion, err := r.ledger.GetPreviousValue(nonce, res.ToModelKey())
			if err == nil && dpVersion == res.Generation {
				if _, ok := out.InProgressResources[key]; !ok {
					out.InProgressResources[key] = len(dataplanes)
				} else {
					out.InProgressResources[key] += len(dataplanes)
				}
			} else if err != nil {
				scope.Errorf("Encountered error retrieving version %s of key %s from Store: %v", nonce, key, err)

package distribution

import (
	"gopkg.in/yaml.v2"
)

type Report struct {
	Reporter            string         `json:"reporter"`
	DataPlaneCount      int            `json:"dataPlaneCount"`
	InProgressResources map[string]int `json:"inProgressResources"`
}

func ReportFromYaml(content []byte) (Report, error) {
	out := Report{}
	err := yaml.Unmarshal(content, &out)
	return out, err

	rpt, prunes := r.buildReport()
	r.removeCompletedResource(prunes)
	Expect(rpt.DataPlaneCount).To(Equal(2))
	Expect(rpt.InProgressResources).To(Equal(map[string]int{
		myResources[0].String(): 2,
		myResources[1].String(): 1,
		myResources[2].String(): 2,
	}))
	Expect(r.inProgressResources).NotTo(ContainElement(resources[0]))

	. "github.com/onsi/gomega"
	"gopkg.in/yaml.v2"

	"istio.io/istio/pilot/pkg/status"
)

func TestReportSerialization(t *testing.T) {
	in := Report{
		Reporter:       "Me",
		DataPlaneCount: 10,
		InProgressResources: map[string]int{
			(&status.Resource{
				Name:      "water",
				Namespace: "default",
			}).String(): 1,
		},
	}
	outbytes, err := yaml.Marshal(in)
	RegisterTestingT(t)
	Expect(err).To(BeNil())

func (c *Controller) handleReport(d Report) {
	defer c.mu.Unlock()
	c.mu.Lock()
	for resstr := range d.InProgressResources {
		res := *status.ResourceFromString(resstr)
		if _, ok := c.CurrentState[res]; !ok {
			c.CurrentState[res] = make(map[string]Progress)
		}
		c.CurrentState[res][d.Reporter] = Progress{d.InProgressResources[resstr], d.DataPlaneCount}
	}
	c.ObservationTime[d.Reporter] = c.clock.Now()
}