func (s *SkewSuite) TestBracketedWrite(c *gc.C) { now := coretesting.ZeroTime() c.Logf("now: %s", now) oneSecondAgo := now.Add(-time.Second) twoSecondsAgo := now.Add(-2 * time.Second) threeSecondsAgo := now.Add(-3 * time.Second) fiveSecondsAgo := now.Add(-5 * time.Second) oneSecondLater := now.Add(time.Second) // Where T is the current local time: // between T-5 and T-1, we read T-2 from the remote clock. skew := lease.Skew{ LastWrite: twoSecondsAgo, Beginning: fiveSecondsAgo, End: oneSecondAgo, } // If the remote wrote a long time ago -- say, 20 minutes ago it thought // it was two seconds before now -- its clock could be arbitrarily far // ahead of ours. But we know that when we started reading, 5 seconds ago, // it might not have seen a time later than 2 seconds in the past; so // right now, five seconds after that, it might not have seen a time later // than three seconds in the future. c.Check(skew.Earliest(now), gc.DeepEquals, threeSecondsAgo) // If the remote wrote at the very last moment -- exactly one second ago, // it thought it was 2 seconds in the past -- it could have a clock one // second behind ours. If so, the *latest* time at which it might still // have thought it was before now is one second in the future. c.Check(skew.Latest(now), gc.DeepEquals, oneSecondLater) }
func (s *SkewSuite) TestApparentFutureWrite(c *gc.C) { now := coretesting.ZeroTime() c.Logf("now: %s", now) oneSecondAgo := now.Add(-time.Second) threeSecondsAgo := now.Add(-3 * time.Second) tenSecondsAgo := now.Add(-10 * time.Second) twelveSecondsAgo := now.Add(-12 * time.Second) nineSecondsLater := now.Add(9 * time.Second) // Where T is the current local time: // between T-3 and T-1, we read T+9 from the remote clock. skew := lease.Skew{ LastWrite: nineSecondsLater, Beginning: threeSecondsAgo, End: oneSecondAgo, } // If the remote wrote a long time ago -- say, 20 minutes ago it thought // it was nine seconds after now -- its clock could be arbitrarily far // ahead of ours. But we know that when we started reading, 3 seconds ago, // it might not have seen a time later than 9 seconds in the future; so // right now, three seconds after that, it might not have seen a time later // than twelve seconds in the future. c.Check(skew.Earliest(now), gc.DeepEquals, twelveSecondsAgo) // If the remote wrote at the very last moment -- exactly one second ago, // it thought it was 9 seconds in the future -- it could have a clock a // full 10 seconds ahead of ours. If so, the *latest* time at which it // might still have thought it was before now is ten seconds in the past. c.Check(skew.Latest(now), gc.DeepEquals, tenSecondsAgo) }
func (s *SkewSuite) TestApparentPastWrite(c *gc.C) { now := coretesting.ZeroTime() c.Logf("now: %s", now) oneSecondAgo := now.Add(-time.Second) threeSecondsAgo := now.Add(-3 * time.Second) nineSecondsAgo := now.Add(-9 * time.Second) sixSecondsLater := now.Add(6 * time.Second) eightSecondsLater := now.Add(8 * time.Second) // Where T is the current local time: // between T-3 and T-1, we read T-9 from the remote clock. skew := lease.Skew{ LastWrite: nineSecondsAgo, Beginning: threeSecondsAgo, End: oneSecondAgo, } // If the remote wrote a long time ago -- say, 20 minutes ago it thought it // was 9 seconds ago -- its clock could be arbitrarily far ahead of ours. // But we know that when we started reading, 3 seconds ago, it might not // have seen a time later than 9 seconds ago; so right now, three seconds // after that, it might not have seen a time later than 6 seconds ago. c.Check(skew.Earliest(now), gc.DeepEquals, sixSecondsLater) // If the remote wrote at the very last moment -- exactly one second ago, // it thought it was nine seconds ago -- it could have a clock a full 8 // seconds behind ours. If so, the *latest* time at which it *might* still // think it's before now is 8 seconds in the future. c.Check(skew.Latest(now), gc.DeepEquals, eightSecondsLater) }
func (s *SkewSuite) TestZero(c *gc.C) { now := coretesting.ZeroTime() // The zero Skew should act as unskewed. skew := lease.Skew{} c.Check(skew.Earliest(now), gc.Equals, now) c.Check(skew.Latest(now), gc.Equals, now) }
func (s *SkewSuite) TestMixedTimezones(c *gc.C) { here := time.FixedZone("here", -3600) there := time.FixedZone("there", -7200) elsewhere := time.FixedZone("elsewhere", -10800) // This is a straight copy of TestBracketedWrite, with strange timezones // inserted to check that they don't affect the results at all. now := coretesting.ZeroTime() c.Logf("now: %s", now) oneSecondAgo := now.Add(-time.Second) twoSecondsAgo := now.Add(-2 * time.Second) threeSecondsAgo := now.Add(-3 * time.Second) fiveSecondsAgo := now.Add(-5 * time.Second) oneSecondLater := now.Add(time.Second) // Where T is the current local time: // between T-5 and T-1, we read T-2 from the remote clock. skew := lease.Skew{ LastWrite: twoSecondsAgo.In(here), Beginning: fiveSecondsAgo.In(there), End: oneSecondAgo.In(elsewhere), } // If the remote wrote a long time ago -- say, 20 minutes ago it thought // it was two seconds before now -- its clock could be arbitrarily far // ahead of ours. But we know that when we started reading, 5 seconds ago, // it might not have seen a time later than 2 seconds in the past; so // right now, five seconds after that, it might not have seen a time later // than three seconds in the future. c.Check(skew.Earliest(now), gc.DeepEquals, threeSecondsAgo.In(there)) // If the remote wrote at the very last moment -- exactly one second ago, // it thought it was 2 seconds in the past -- it could have a clock one // second behind ours. If so, the *latest* time at which it might still // have thought it was before now is one second in the future. c.Check(skew.Latest(now), gc.DeepEquals, oneSecondLater.In(elsewhere)) }