HomeMesosphereNo notifications. 4 unresolved issues.
  • Search
Differential D313

Fix incorrect conversion from TaskStatus.timestamp to Timestamp
ClosedAll Users
Actions

Authored by meichstedt on Dec 10 2016, 1:49 PM.

Details

Reviewers
aquamatthias
jeschkies
Commits
rMARATHON4dfbbc1d0aea: Fix incorrect conversion from TaskStatus.timestamp to Timestamp
rMARATHON882a0f307e00: Fix incorrect conversion from TaskStatus.timestamp to Timestamp
rMARATHONa4c83a21fc4b: Fix incorrect conversion from TaskStatus.timestamp to Timestamp
Summary

The timestap as provided by Mesos TaskStatus has unit seconds, not microseconds.

Test Plan

sbt test

Diff Detail

Repository
rMARATHON marathon
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.
Changes from before your most recent comment are hidden. Show Older Changes
jeschkies accepted this revision.Dec 12 2016, 10:49 AM

Thanks. Do you have a link to the Mesos docs we could add?

Closed by commit rMARATHON4dfbbc1d0aea: Fix incorrect conversion from TaskStatus.timestamp to Timestamp (authored by meichstedt, committed by unterstein). · Explain WhyDec 12 2016, 10:52 AM
This revision was automatically updated to reflect the committed changes.
meichstedt added a comment.Dec 12 2016, 11:45 AM
In D313#9822, @jeschkies wrote:

Thanks. Do you have a link to the Mesos docs we could add?

Unfortunately, there is no link as there are no docs – who needs a documented API anyways ;)

The timestamp in TaskStatus is not documented at all. The doc on timestamp in e.g. ResourceStatistics
https://github.com/apache/mesos/blob/master/include/mesos/mesos.proto#L1069
states it's the Snapshot time, in seconds since the Epoch, but for the TaskStatus.timestamp we'd need to create a PR. I'll see what I can do.

Revision Contents

Diff 1217

View Options

src/main/scala/mesosphere/marathon/core/task/Task.scala

11package mesosphere.marathon
22package core.task
33
44import java.util.Base64
5import java.util.concurrent.TimeUnit
65
76import com.fasterxml.uuid.{ EthernetAddress, Generators }
87import mesosphere.marathon.core.condition.Condition
98import mesosphere.marathon.core.condition.Condition.Terminal
109import mesosphere.marathon.core.instance.Instance
1110import mesosphere.marathon.core.pod.MesosContainer
1211import mesosphere.marathon.core.task.Task.Reservation.Timeout.Reason.{ RelaunchEscalationTimeout, ReservationTimeout }
1312import mesosphere.marathon.core.task.state.NetworkInfo
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Line(s)
8685 /**
8786 * @return whether task has an unreachable Mesos status longer than timeout.
8887 */
8988 def isUnreachableExpired(now: Timestamp, timeout: FiniteDuration): Boolean = {
9089 if (status.condition == Condition.Unreachable || status.condition == Condition.UnreachableInactive) {
9190 status.mesosStatus.exists { status =>
9291 val since: Timestamp =
9392 if (status.hasUnreachableTime) status.getUnreachableTime
94 else Timestamp(TimeUnit.MICROSECONDS.toMillis(status.getTimestamp.toLong))
93 else Timestamp.fromTaskStatus(status)
9594
9695 since.expired(now, by = timeout)
9796 }
9897 } else false
9998 }
10099}
101100
102101object Task {
▲ Show 20 Lines • Show All 454 Lines • Show Last 20 Lines
View Options

src/main/scala/mesosphere/marathon/state/Timestamp.scala

11package mesosphere.marathon
22package state
33
44import java.time.{ Instant, OffsetDateTime }
55import java.util.concurrent.TimeUnit
66
7import org.apache.mesos.Protos.TimeInfo
7import org.apache.mesos
88import org.joda.time.{ DateTime, DateTimeZone }
99
1010import scala.concurrent.duration.FiniteDuration
1111import scala.language.implicitConversions
1212import scala.math.Ordered
1313
1414/**
1515 * An ordered wrapper for UTC timestamps.
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Line(s)
7777 * Returns a new Timestamp representing the current instant.
7878 */
7979 def now(): Timestamp = Timestamp(System.currentTimeMillis)
8080
8181 def zero: Timestamp = Timestamp(0)
8282
8383 /**
8484 * Convert Mesos TimeInfo to Timestamp.
85 *
86 * @param timeInfo
8785 * @return Timestamp for TimeInfo
8886 */
89 implicit def toTimestamp(timeInfo: TimeInfo): Timestamp = {
87 implicit def toTimestamp(timeInfo: mesos.Protos.TimeInfo): Timestamp = {
9088 apply(TimeUnit.NANOSECONDS.toMillis(timeInfo.getNanoseconds))
89 }
90
91 /**
92 * Convert Mesos TaskStatus to Timestamp.
93 * @return Timestamp based on the timestamp (in seconds) from the given TaskStatus
94 */
95 def fromTaskStatus(taskStatus: mesos.Protos.TaskStatus): Timestamp = {
96 apply(TimeUnit.SECONDS.toMillis(taskStatus.getTimestamp.toLong))
9197 }
9298}
View Options

src/test/scala/mesosphere/marathon/core/task/bus/MesosTaskStatusTestHelper.scala

Show All 12 Lines
1313 def mesosStatus(
1414 state: TaskState,
1515 maybeHealthy: Option[Boolean] = None,
1616 maybeReason: Option[Reason] = None,
1717 maybeMessage: Option[String] = None,
1818 timestamp: Timestamp = Timestamp.zero,
1919 taskId: Task.Id = Task.Id(UUID.randomUUID().toString)): TaskStatus = {
2020
21 val seconds = timestamp.millis / 1000
2122 val mesosStatus = TaskStatus.newBuilder
2223 .setTaskId(taskId.mesosTaskId)
2324 .setState(state)
24 .setTimestamp(timestamp.micros.toDouble)
25 .setTimestamp(seconds.toDouble)
2526 maybeHealthy.foreach(mesosStatus.setHealthy)
2627 maybeReason.foreach(mesosStatus.setReason)
2728 maybeMessage.foreach(mesosStatus.setMessage)
2829 mesosStatus.build()
2930 }
3031
3132 def mesosStatus(condition: Condition, taskId: Task.Id, since: Timestamp): Option[TaskStatus] = {
3233 condition match {
Show All 40 Lines
View Options

src/test/scala/mesosphere/marathon/state/TimestampTest.scala

11package mesosphere.marathon
22package state
33
4import mesosphere.marathon.test.MarathonSpec
4import java.time.Instant
5import java.time.temporal.ChronoUnit
6
7import mesosphere.UnitTest
58import org.joda.time.{ DateTime, DateTimeZone }
69
710import scala.concurrent.duration._
811
9class TimestampTest extends MarathonSpec {
12class TimestampTest extends UnitTest {
1013
11 test("Ordering") {
14 "Timestamp" when {
15 "ordering" should {
16 "have the correct order" in {
1217 val t1 = Timestamp(1024)
1318 val t2 = Timestamp(2048)
14 assert(t1.compare(t2) < 0)
19 t1.compare(t2) should be < 0
1520 }
16
17 test("Before") {
21 "be before" in {
1822 val t1 = Timestamp(1024)
1923 val t2 = Timestamp(2048)
20 assert(t1.before(t2))
24 t1.before(t2) shouldBe true
2125 }
22
23 test("After") {
26 "be after" in {
2427 val t1 = Timestamp(1024)
2528 val t2 = Timestamp(2048)
26 assert(t2.after(t1))
29 t2.after(t1) shouldBe true
2730 }
28
29 test("Older") {
31 "be older" in {
3032 val t1 = Timestamp(1024)
3133 val t2 = Timestamp(2048)
32 assert(t1.olderThan(t2))
34 t1.olderThan(t2) shouldBe true
3335 }
34
35 test("Younger") {
36 "be younger" in {
3637 val t1 = Timestamp(1024)
3738 val t2 = Timestamp(2048)
38 assert(t2.youngerThan(t1))
39 t2.youngerThan(t1) shouldBe true
3940 }
40
41 test("Expire") {
41 "be expired" in {
4242 val t1 = Timestamp(1024)
4343 val t2 = Timestamp(2048)
44 assert(!t1.expired(t2, by = 100.minutes))
45 assert(t1.expired(t2, by = 10.millis))
44 t1.expired(t2, by = 100.minutes) shouldBe false
45 t1.expired(t2, by = 10.millis) shouldBe true
4646 }
47
48 test("Independent of timezone") {
47 "independent of timezone" in {
4948 val t1 = Timestamp(1024)
5049 val t2 = Timestamp(new DateTime(1024).toDateTime(DateTimeZone.forOffsetHours(2))) // linter:ignore TypeToType
5150
52 assert(t1 == t2)
53 assert(t1.hashCode == t2.hashCode)
51 (t1 == t2) shouldBe true
52 (t1.hashCode == t2.hashCode) shouldBe true
53 }
54 }
55 "converting from Mesos" should {
56 import org.apache.mesos
57 "resolve TaskStatus.timestamp correctly" in {
58 val instant = Instant.now()
59 val taskStatus = mesos.Protos.TaskStatus.newBuilder()
60 .setTimestamp(instant.getEpochSecond.toDouble)
61 .setTaskId(mesos.Protos.TaskID.newBuilder().setValue("task-1").build())
62 .setState(mesos.Protos.TaskState.TASK_STAGING)
63 .build()
64 val timestamp = Timestamp.fromTaskStatus(taskStatus)
65
66 // We loose precision, therefore need to truncate the instant to seconds
67 timestamp.millis shouldEqual instant.truncatedTo(ChronoUnit.SECONDS).toEpochMilli
68 }
69 }
5470 }
5571}