func (h *DesiredLRPHandler) Create(w http.ResponseWriter, r *http.Request) {
	log := h.logger.Session("create")
	desireLRPRequest := receptor.DesiredLRPCreateRequest{}

	err := json.NewDecoder(r.Body).Decode(&desireLRPRequest)
	if err != nil {
		log.Error("invalid-json", err)
		writeBadRequestResponse(w, receptor.InvalidJSON, err)
		return
	}

	desiredLRP := serialization.DesiredLRPFromRequest(desireLRPRequest)

	err = h.legacyBBS.DesireLRP(log, desiredLRP)
	if err != nil {
		if _, ok := err.(oldmodels.ValidationError); ok {
			log.Error("lrp-request-invalid", err)
			writeBadRequestResponse(w, receptor.InvalidLRP, err)
			return
		}

		if err == bbserrors.ErrStoreResourceExists {
			writeDesiredLRPAlreadyExistsResponse(w, desiredLRP.ProcessGuid)
			return
		}

		log.Error("desire-lrp-failed", err)
		writeUnknownErrorResponse(w, err)
		return
	}

	w.WriteHeader(http.StatusCreated)
}
Example #2
0
					User: "******",
					Path: "the-path",
				},
				StartTimeout: 4,
				Privileged:   true,
				LogGuid:      "log-guid-0",
				LogSource:    "log-source-name-0",
				MetricsGuid:  "metrics-guid-0",
				EgressRules: []models.SecurityGroupRule{
					securityRule,
				},
				Routes: routingInfo,
			}
		})
		JustBeforeEach(func() {
			desiredLRP = serialization.DesiredLRPFromRequest(request)
		})

		It("translates the request into a DesiredLRP model, preserving attributes", func() {
			Expect(desiredLRP.ProcessGuid).To(Equal("the-process-guid"))
			Expect(desiredLRP.Domain).To(Equal("the-domain"))
			Expect(desiredLRP.RootFS).To(Equal("the-rootfs"))
			Expect(desiredLRP.Annotation).To(Equal("foo"))
			Expect(desiredLRP.StartTimeout).To(Equal(uint(4)))
			Expect(desiredLRP.Ports).To(HaveLen(2))
			Expect(desiredLRP.Ports[0]).To(Equal(uint16(2345)))
			Expect(desiredLRP.Ports[1]).To(Equal(uint16(6789)))
			Expect(desiredLRP.Privileged).To(BeTrue())
			Expect(desiredLRP.EgressRules).To(HaveLen(1))
			Expect(desiredLRP.EgressRules[0].Protocol).To(Equal(securityRule.Protocol))
			Expect(desiredLRP.EgressRules[0].PortRange).To(Equal(securityRule.PortRange))