Initial distributor implementation

common/api/dm/service/v1/graph_data_purge_timestamps.go

Index: common/api/dm/service/v1/graph_data_purge_timestamps.go
diff --git a/common/api/dm/service/v1/graph_data_purge_timestamps.go b/common/api/dm/service/v1/graph_data_purge_timestamps.go
new file mode 100644
index 0000000000000000000000000000000000000000..888ed37162ed3465787b986d4c19b9b84e02d426
--- /dev/null
+++ b/common/api/dm/service/v1/graph_data_purge_timestamps.go
@@ -0,0 +1,90 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package dm
+
+// TimestampPurger is for testing: invoking this on a struct in this package

[dnj (Google), 2016/06/09 18:00:57]

I assume you have a good reason for this, so just a comment:

In general, I'd prefer you not do this. Since we have a test clock, we can
control timestamps easily, and differences in timestamp expectations can point
out real problems.

[iannucci, 2016/06/15 00:46:02]

There's so much parallelism going on that it's not worth it to capture the
timestamps in the integration tests. Using testclock in a non-parallel unittest
is fine (which is what I do).

+// will remove all timestamps from it. This is useful for testing where the
+// timestamps are frequently just noise.
+type TimestampPurger interface {
+	PurgeTimestamps()
+}
+
+// PurgeTimestamps implements TimestampPurger.
+func (g *GraphData) PurgeTimestamps() {
+	if g == nil {
+		return
+	}
+	for _, q := range g.Quests {
+		q.PurgeTimestamps()
+	}
+}
+
+// PurgeTimestamps implements TimestampPurger.
+func (q *Quest) PurgeTimestamps() {
+	if q == nil {
+		return
+	}
+	q.Data.PurgeTimestamps()
+	for _, a := range q.Attempts {
+		a.PurgeTimestamps()
+	}
+}
+
+// PurgeTimestamps implements TimestampPurger.
+func (qd *Quest_Data) PurgeTimestamps() {
+	if qd == nil {
+		return
+	}
+	qd.Created = nil
+}
+
+// PurgeTimestamps implements TimestampPurger.
+func (a *Attempt) PurgeTimestamps() {
+	if a == nil {
+		return
+	}
+	a.Data.PurgeTimestamps()
+
+	for _, e := range a.Executions {
+		e.PurgeTimestamps()
+	}
+}
+
+// PurgeTimestamps implements TimestampPurger.
+func (ad *Attempt_Data) PurgeTimestamps() {
+	if ad == nil {
+		return
+	}
+	ad.Created = nil
+	ad.Modified = nil
+	if p, _ := ad.AttemptType.(TimestampPurger); p != nil {
+		p.PurgeTimestamps()
+	}
+}
+
+// PurgeTimestamps implements TimestampPurger.
+func (f *Attempt_Data_Finished_) PurgeTimestamps() {
+	if f == nil || f.Finished == nil {
+		return
+	}
+	f.Finished.Expiration = nil
+}
+
+// PurgeTimestamps implements TimestampPurger.
+func (e *Execution) PurgeTimestamps() {
+	if e == nil {
+		return
+	}
+	e.Data.PurgeTimestamps()
+}
+
+// PurgeTimestamps implements TimestampPurger.
+func (ed *Execution_Data) PurgeTimestamps() {
+	if ed == nil {
+		return
+	}
+	ed.Created = nil
+	ed.Modified = nil
+}