HomeMesosphereNo notifications. 4 unresolved issues.
  • Search
Differential D27

Support version endpoints for pods.
AbandonedAll Users
Actions

Authored by • jasongilanfarr on Sep 27 2016, 9:25 PM.

Details

Reviewers
aquamatthias
jdef
Commits
rMARATHON675ff0940aab: Support version endpoints for pods.
rMARATHON0a070d322cea: Merge 675ff0940aab098c99509d0ddc7d7f6e19762ce7 into…
rMARATHON477e8d471e65: Support version endpoints for pods.
Summary
  • Add support for the version endpoints described in DCOS-1004
Test Plan

sbt test

Diff Detail

Repository
rMARATHON marathon
Branch
jason/pod-versions
Lint
No Linters Available
Unit
No Unit Test Coverage
Build Status
Buildable 44
Build 44: arc lint + arc unit
• jasongilanfarr retitled this revision from to Support version endpoints for pods..Sep 27 2016, 9:25 PM
• jasongilanfarr updated this object.
• jasongilanfarr edited the test plan for this revision. (Show Details)
• jasongilanfarr added reviewers: jdef, aquamatthias.
• jasongilanfarr added a subscriber: marathon-team.
jdef added inline comments.Sep 27 2016, 10:42 PM
src/main/scala/mesosphere/marathon/api/v2/PodsResource.scala
210

probably want authz here

222

you probably want authz here (withAuthorization(ViewRunSpec, ..))

• jasongilanfarr abandoned this revision.Sep 28 2016, 8:59 PM

Merged into feature/pods

Revision Contents

Diff 48

View Options

docs/docs/rest-api/public/api/v2/pods.raml

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Line(s)
115115 is: [ secured, objectLocator ]
116116 description: |
117117 Get the status of the pod with the given id
118118 responses:
119119 200:
120120 body:
121121 application/json:
122122 type: podStatus.PodStatus
123
124'/{id}::versions':
125 description: |
126 Implementations should probably generate do-not-cache headers because
127 status should always be live.
128 uriParameters:
129 id:
130 type: strings.PathId
131 description: The path of the pod
132 get:
133 is: [ secured, objectLocator ]
134 description: |
135 List the versions of this pod.
136 responses:
137 200:
138 body:
139 application/json:
140 type: string[]
141
142'/{id}::versions/{version}':
143 uriParameters:
144 id:
145 type: strings.PathId
146 description: The path of the pod
147 version:
148 type: string
149 description: The version of the pod
150 get:
151 is: [ secured, objectLocator ]
152 description: |
153 List the versions of this pod.
154 responses:
155 200:
156 body:
157 application/json:
158 type: pod.Pod
View Options

src/main/scala/mesosphere/marathon/api/v2/PodsResource.scala

11package mesosphere.marathon.api.v2
22
33import java.net.URI
44import javax.inject.Inject
55import javax.servlet.http.HttpServletRequest
66import javax.ws.rs._
77import javax.ws.rs.core.Response.Status
8import javax.ws.rs.core.{ Context, MediaType, Response }
8import javax.ws.rs.core.{Context, MediaType, Response}
99
1010import akka.event.EventStream
1111import akka.stream.Materializer
1212import akka.stream.scaladsl.Sink
1313import com.codahale.metrics.annotation.Timed
1414import mesosphere.marathon.MarathonConf
1515import mesosphere.marathon.api.v2.validation.PodsValidation
16import mesosphere.marathon.api.{ AuthResource, MarathonMediaType, RestResource }
17import mesosphere.marathon.core.appinfo.{ PodSelector, PodStatusService, Selector }
16import mesosphere.marathon.api.{AuthResource, MarathonMediaType, RestResource}
17import mesosphere.marathon.core.appinfo.{PodSelector, PodStatusService, Selector}
1818import mesosphere.marathon.core.event._
19import mesosphere.marathon.core.pod.{ PodDefinition, PodManager }
19import mesosphere.marathon.core.pod.{PodDefinition, PodManager}
2020import mesosphere.marathon.plugin.auth._
21import mesosphere.marathon.raml.{ Pod, Raml }
22import mesosphere.marathon.state.PathId
21import mesosphere.marathon.raml.{Pod, Raml}
22import mesosphere.marathon.state.{PathId, Timestamp}
2323import play.api.libs.json.Json
2424
2525@Path("v2/pods")
2626@Consumes(Array(MediaType.APPLICATION_JSON))
2727@Produces(Array(MarathonMediaType.PREFERRED_APPLICATION_JSON))
2828class PodsResource @Inject() (
2929 val config: MarathonConf)(
3030 implicit
▲ Show 20 Lines • Show All 161 Lines • ▼ Show 20 Line(s)
192192
193193 withValid(id.toRootPath) { id =>
194194 val maybeStatus = podStatusService.selectPodStatus(id, authzSelector)
195195 result(maybeStatus).fold(notFound(id)) { status =>
196196 ok(Json.stringify(Json.toJson(status)))
197197 }
198198 }
199199 }
200
201 @GET
202 @Timed
203 @Path("""{id:+}::versions""")
204 def versions(@PathParam("id") id: String,
205 @Context req: HttpServletRequest): Response = authenticated(req) { implicit identity =>
206 import PathId._
207 import mesosphere.marathon.api.v2.json.Formats.TimestampFormat
208 withValid(id.toRootPath) { id =>
209 val versions = podSystem.versions(id).runWith(Sink.seq)
210 ok(Json.stringify(Json.toJson(result(versions))))
jdefUnsubmitted
Not Done

probably want authz here

211 }
212 }
213
214 @GET
215 @Timed
216 @Path("""{id:+}::versions/{version}""")
217 def version(@PathParam("id") id: String, @PathParam("version") versionString: String,
218 @Context req: HttpServletRequest): Response = authenticated(req) { implicit identity =>
219 import PathId._
220 val version = Timestamp(versionString)
221 withValid(id.toRootPath) { id =>
222 result(podSystem.version(id, version)).fold(notFound(id)) { pod =>
jdefUnsubmitted
Not Done

you probably want authz here (withAuthorization(ViewRunSpec, ..))

223 ok(Json.stringify(Json.toJson(Raml.toRaml(pod))))
224 }
225 }
226 }
227
200228
201229 private def notFound(id: PathId): Response = notFound(s"""{"message": "pod '$id' does not exist"}""")
202230}
203231
204232object PodsResource {
205233 val DeploymentHeader = "Marathon-Deployment-Id"
206234
207235 def authzSelector(implicit authz: Authorizer, identity: Identity): PodSelector = Selector[PodDefinition] { pod =>
208236 authz.isAuthorized(identity, ViewRunSpec, pod)
209237 }
210238}
View Options

src/main/scala/mesosphere/marathon/core/CoreModuleImpl.scala

Show First 20 Lines • Show All 193 Lines • ▼ Show 20 Line(s)
194194 storageModule.groupRepository,
195195 storage,
196196 eventStream,
197197 metrics)(actorsModule.materializer)
198198
199199 // PODS
200200
201201 override lazy val podModule: PodModule =
202 PodModule(groupManagerModule.groupManager)(ExecutionContext.global)
202 PodModule(groupManagerModule.groupManager, storageModule.podRepository)(ExecutionContext.global)
203203
204204 // GREEDY INSTANTIATION
205205 //
206206 // Greedily instantiate everything.
207207 //
208208 // lazy val allows us to write down object instantiations in any order.
209209 //
210210 // The LeadershipModule requires that all actors have been registered when the controller
Show All 18 Lines
View Options

src/main/scala/mesosphere/marathon/core/pod/PodManager.scala

11package mesosphere.marathon.core.pod
22
33import akka.NotUsed
44import akka.stream.scaladsl.Source
5import mesosphere.marathon.state.PathId
5import mesosphere.marathon.state.{PathId, Timestamp}
66import mesosphere.marathon.upgrade.DeploymentPlan
77
88import scala.concurrent.Future
99
1010trait PodManager {
1111
1212 def create(p: PodDefinition, force: Boolean): Future[DeploymentPlan]
1313 def findAll(s: (PodDefinition) => Boolean): Source[PodDefinition, NotUsed]
1414 def find(id: PathId): Future[Option[PodDefinition]]
1515 def update(p: PodDefinition, force: Boolean): Future[DeploymentPlan]
1616 def delete(id: PathId, force: Boolean): Future[DeploymentPlan]
17 def versions(id: PathId): Source[Timestamp, NotUsed]
18 def version(id: PathId, version: Timestamp): Future[Option[PodDefinition]]
1719}
View Options

src/main/scala/mesosphere/marathon/core/pod/PodModule.scala

11package mesosphere.marathon.core.pod
22
33import mesosphere.marathon.core.group.GroupManager
44import mesosphere.marathon.core.pod.impl.PodManagerImpl
5import mesosphere.marathon.storage.repository.ReadOnlyPodRepository
56
67import scala.concurrent.ExecutionContext
78
89case class PodModule(
9 groupManager: GroupManager)(implicit ctx: ExecutionContext) {
10 groupManager: GroupManager,
11 podRepository: ReadOnlyPodRepository)(implicit ctx: ExecutionContext) {
1012
11 lazy val podManager: PodManager = new PodManagerImpl(groupManager)
13 lazy val podManager: PodManager = new PodManagerImpl(groupManager, podRepository)
1214}
View Options

src/main/scala/mesosphere/marathon/core/pod/impl/PodManagerImpl.scala

11package mesosphere.marathon.core.pod.impl
22
33import akka.NotUsed
44import akka.stream.scaladsl.Source
55import mesosphere.marathon.ConflictingChangeException
66import mesosphere.marathon.core.group.GroupManager
7import mesosphere.marathon.core.pod.{ PodDefinition, PodManager }
8import mesosphere.marathon.state.PathId
7import mesosphere.marathon.core.pod.{PodDefinition, PodManager}
8import mesosphere.marathon.state.{PathId, Timestamp}
9import mesosphere.marathon.storage.repository.ReadOnlyPodRepository
910import mesosphere.marathon.upgrade.DeploymentPlan
1011
1112import scala.collection.immutable.Seq
12import scala.concurrent.{ ExecutionContext, Future }
13import scala.concurrent.{ExecutionContext, Future}
1314
14class PodManagerImpl(
15 groupManager: GroupManager)(implicit ctx: ExecutionContext) extends PodManager {
15case class PodManagerImpl(
16 groupManager: GroupManager,
17 podRepository: ReadOnlyPodRepository)(implicit ctx: ExecutionContext) extends PodManager {
1618
1719 def create(p: PodDefinition, force: Boolean): Future[DeploymentPlan] = {
1820 def createOrThrow(opt: Option[PodDefinition]) = opt
1921 .map(_ => throw ConflictingChangeException(s"A pod with id [${p.id}] already exists."))
2022 .getOrElse(p)
2123 groupManager.updatePod(p.id, createOrThrow, p.version, force)
2224 }
2325
2426 def findAll(filter: (PodDefinition) => Boolean): Source[PodDefinition, NotUsed] = {
2527 val pods = groupManager.rootGroup().map(_.transitivePodsById.values.filter(filter).to[Seq])
2628 Source.fromFuture(pods).mapConcat(identity)
2729 }
2830
2931 def find(id: PathId): Future[Option[PodDefinition]] = groupManager.pod(id)
3032
3133 def update(p: PodDefinition, force: Boolean): Future[DeploymentPlan] =
3234 groupManager.updatePod(p.id, _ => p, p.version, force)
3335
3436 def delete(id: PathId, force: Boolean): Future[DeploymentPlan] = {
3537 groupManager.update(id.parent, _.removePod(id), force = force)
38 }
39
40 override def versions(id: PathId): Source[Timestamp, NotUsed] = {
41 podRepository.versions(id).map(Timestamp(_))
42 }
43
44 override def version(id: PathId, version: Timestamp): Future[Option[PodDefinition]] = {
45 podRepository.getVersion(id, version.toOffsetDateTime)
3646 }
3747}
View Options

src/test/scala/mesosphere/marathon/api/v2/PodsResourceTest.scala

11package mesosphere.marathon.api.v2
22
33import javax.servlet.http.HttpServletResponse
44
55import akka.event.EventStream
66import akka.stream.Materializer
7import com.codahale.metrics.MetricRegistry
8import mesosphere.AkkaUnitTest
79import mesosphere.marathon._
810import mesosphere.marathon.api.TestAuthFixture
911import mesosphere.marathon.core.appinfo.PodStatusService
10import mesosphere.marathon.core.pod.{ PodDefinition, PodManager }
11import mesosphere.marathon.plugin.auth.{ Authenticator, Authorizer }
12import mesosphere.marathon.raml.Pod
13import mesosphere.marathon.test.{ MarathonSpec, Mockito }
12import mesosphere.marathon.core.group.GroupManager
13import mesosphere.marathon.core.pod.impl.PodManagerImpl
14import mesosphere.marathon.core.pod.{PodDefinition, PodManager}
15import mesosphere.marathon.core.storage.store.impl.memory.InMemoryPersistenceStore
16import mesosphere.marathon.metrics.Metrics
17import mesosphere.marathon.plugin.auth.{Authenticator, Authorizer}
18import mesosphere.marathon.raml.{Pod, Raml}
19import mesosphere.marathon.state.Timestamp
20import mesosphere.marathon.storage.repository.PodRepository
21import mesosphere.marathon.test.Mockito
1422import mesosphere.marathon.upgrade.DeploymentPlan
15import org.scalatest.Matchers
1623import play.api.libs.json._
1724
18import scala.concurrent.Future
25import scala.concurrent.{ExecutionContext, Future}
26import scala.concurrent.duration._
27import scala.collection.immutable.Seq
1928
20class PodsResourceTest extends MarathonSpec with Matchers with Mockito {
29class PodsResourceTest extends AkkaUnitTest with Mockito {
2130
2231 // TODO(jdef) test findAll
2332 // TODO(jdef) test status
2433 // TODO(jdef) incorporate checks for firing pod events on C, U, D operations
2534
26 test("Marathon supports pods") {
27 val f = Fixture.create()
35 "PodsResource" should {
36 "support pods" in {
37 val f = Fixture()
2838 val response = f.podsResource.capability(f.auth.request)
2939 response.getStatus should be(HttpServletResponse.SC_OK)
3040
3141 val body = Option(response.getEntity.asInstanceOf[String])
3242 body should be(None)
3343 }
3444
35 test("create a simple single-container pod from docker image w/ shell command") {
45 "be able to create a simple single-container pod from docker image w/ shell command" in {
3646 implicit val podSystem = mock[PodManager]
37 val f = Fixture.create()
47 val f = Fixture()
3848
3949 podSystem.create(any, eq(false)).returns(Future.successful(DeploymentPlan.empty))
4050
4151 val postJson = """
4252 | { "id": "/mypod", "networks": [ { "mode": "host" } ], "containers": [
4353 | { "name": "webapp",
4454 | "resources": { "cpus": 0.03, "mem": 64 },
4555 | "image": { "kind": "DOCKER", "id": "busybox" },
4656 | "exec": { "command": { "shell": "sleep 1" } } } ] }
4757 """.stripMargin
4858 val response = f.podsResource.create(postJson.getBytes(), false, f.auth.request)
4959
5060 withClue(s"response body: ${response.getEntity}") {
51 response.getStatus() should be(HttpServletResponse.SC_CREATED)
61 response.getStatus should be(HttpServletResponse.SC_CREATED)
5262
5363 val parsedResponse = Option(response.getEntity.asInstanceOf[String]).map(Json.parse)
5464 parsedResponse should not be (None)
5565 parsedResponse.map(_.as[Pod]) should not be (None) // validate that we DID get back a pod definition
5666
57 response.getMetadata().containsKey(PodsResource.DeploymentHeader) should be(true)
67 response.getMetadata.containsKey(PodsResource.DeploymentHeader) should be(true)
5868 }
5969 }
6070
61 test("update a simple single-container pod from docker image w/ shell command") {
71 "update a simple single-container pod from docker image w/ shell command" in {
6272 implicit val podSystem = mock[PodManager]
63 val f = Fixture.create()
73 val f = Fixture()
6474
6575 podSystem.update(any, eq(false)).returns(Future.successful(DeploymentPlan.empty))
6676
6777 val postJson = """
6878 | { "id": "/mypod", "networks": [ { "mode": "host" } ], "containers": [
6979 | { "name": "webapp",
7080 | "resources": { "cpus": 0.03, "mem": 64 },
7181 | "image": { "kind": "DOCKER", "id": "busybox" },
7282 | "exec": { "command": { "shell": "sleep 1" } } } ] }
7383 """.stripMargin
7484 val response = f.podsResource.update("/mypod", postJson.getBytes(), false, f.auth.request)
7585
7686 withClue(s"response body: ${response.getEntity}") {
77 response.getStatus() should be(HttpServletResponse.SC_OK)
87 response.getStatus should be(HttpServletResponse.SC_OK)
7888
7989 val parsedResponse = Option(response.getEntity.asInstanceOf[String]).map(Json.parse)
8090 parsedResponse should not be (None)
8191 parsedResponse.map(_.as[Pod]) should not be (None) // validate that we DID get back a pod definition
8292
83 response.getMetadata().containsKey(PodsResource.DeploymentHeader) should be(true)
93 response.getMetadata.containsKey(PodsResource.DeploymentHeader) should be(true)
8494 }
8595 }
8696
87 test("delete a pod") {
97 "delete a pod" in {
8898 implicit val podSystem = mock[PodManager]
89 val f = Fixture.create()
99 val f = Fixture()
90100
91101 podSystem.find(any).returns(Future.successful(Some(PodDefinition())))
92102 podSystem.delete(any, eq(false)).returns(Future.successful(DeploymentPlan.empty))
93103 val response = f.podsResource.remove("/mypod", false, f.auth.request)
94104
95105 withClue(s"response body: ${response.getEntity}") {
96 response.getStatus() should be(HttpServletResponse.SC_ACCEPTED)
106 response.getStatus should be(HttpServletResponse.SC_ACCEPTED)
97107
98108 val body = Option(response.getEntity.asInstanceOf[String])
99109 body should be(None)
100110
101 response.getMetadata().containsKey(PodsResource.DeploymentHeader) should be(true)
111 response.getMetadata.containsKey(PodsResource.DeploymentHeader) should be(true)
102112 }
103113 }
104114
105 test("lookup a specific pod, and that pod does not exist") {
115 "lookup a specific pod, and that pod does not exist" in {
106116 implicit val podSystem = mock[PodManager]
107 val f = Fixture.create()
117 val f = Fixture()
108118
109119 podSystem.find(any).returns(Future.successful(Option.empty[PodDefinition]))
110120 val response = f.podsResource.find("/mypod", f.auth.request)
111121
112122 withClue(s"response body: ${response.getEntity}") {
113 response.getStatus() should be(HttpServletResponse.SC_NOT_FOUND)
123 response.getStatus should be(HttpServletResponse.SC_NOT_FOUND)
114124 val body = Option(response.getEntity.asInstanceOf[String])
115125 body should not be (None)
116126 body.foreach(_ should include("mypod does not exist"))
117127 }
118128 }
119129
130 "support versions" when {
131 implicit val metrics = new Metrics(new MetricRegistry)
132 implicit val ctx = ExecutionContext.global
133
134 "there are no versions" when {
135 "list no versions" in {
136 val podRepository = PodRepository.inMemRepository(new InMemoryPersistenceStore())
137 implicit val podManager = PodManagerImpl(mock[GroupManager], podRepository)
138 val f = Fixture()
139
140 val response = f.podsResource.versions("/id", f.auth.request)
141 withClue(s"response body: ${response.getEntity}") {
142 response.getStatus should be(HttpServletResponse.SC_OK)
143 val body = response.getEntity.asInstanceOf[String]
144 body should equal("[]")
145 }
146 }
147 "return 404 when asking for a version" in {
148 val podRepository = PodRepository.inMemRepository(new InMemoryPersistenceStore())
149 implicit val podManager = PodManagerImpl(mock[GroupManager], podRepository)
150 val f = Fixture()
151
152 val response = f.podsResource.version("/id", "2008", f.auth.request)
153 withClue(s"response body: ${response.getEntity}") {
154 response.getStatus should be(HttpServletResponse.SC_NOT_FOUND)
155 }
156 }
157 }
158 "there are versions" when {
159 import mesosphere.marathon.api.v2.json.Formats.TimestampFormat
160 import mesosphere.marathon.state.PathId._
161 val pod1 = PodDefinition("/id".toRootPath)
162 val pod2 = pod1.copy(version = pod1.version + 1.minute)
163 "list the available versions" in {
164 val podRepository = PodRepository.inMemRepository(new InMemoryPersistenceStore())
165 podRepository.store(pod1).futureValue
166 podRepository.store(pod2).futureValue
167 implicit val podManager = PodManagerImpl(mock[GroupManager], podRepository)
168 val f = Fixture()
169
170 val response = f.podsResource.versions("/id", f.auth.request)
171 withClue(s"reponse body: ${response.getEntity}") {
172 response.getStatus should be(HttpServletResponse.SC_OK)
173 val timestamps = Json.fromJson[Seq[Timestamp]](Json.parse(response.getEntity.asInstanceOf[String])).get
174 timestamps should contain theSameElementsAs Seq(pod1.version, pod2.version)
175 }
176 }
177 "get a specific version" in {
178 val podRepository = PodRepository.inMemRepository(new InMemoryPersistenceStore())
179 podRepository.store(pod1).futureValue
180 podRepository.store(pod2).futureValue
181 implicit val podManager = PodManagerImpl(mock[GroupManager], podRepository)
182 val f = Fixture()
183
184 val response = f.podsResource.version("/id", pod1.version.toString, f.auth.request)
185 withClue(s"reponse body: ${response.getEntity}") {
186 response.getStatus should be(HttpServletResponse.SC_OK)
187 val pod = Raml.fromRaml(Json.fromJson[Pod](Json.parse(response.getEntity.asInstanceOf[String])).get)
188 pod should equal(pod1)
189 }
190 }
191 }
192 }
193 }
194
120195 case class Fixture(
121196 podsResource: PodsResource,
122197 auth: TestAuthFixture,
123198 podSystem: PodManager
124199 )
125200
126201 object Fixture {
127 def create(
202 def apply(
128203 configArgs: Seq[String] = Seq.empty[String],
129204 auth: TestAuthFixture = new TestAuthFixture()
130205 )(implicit
131206 podSystem: PodManager = mock[PodManager],
132207 podStatusService: PodStatusService = mock[PodStatusService],
133208 eventBus: EventStream = mock[EventStream],
134209 mat: Materializer = mock[Materializer]): Fixture = {
135210 val config = AllConf.withTestConfig(configArgs: _*)
Show All 10 Lines