Esempio n. 1
0
func (w *Writer) handle(rw http.ResponseWriter, r *http.Request) {
	w.readers.Add(1)
	defer w.readers.Done()

	if r.RequestURI == "/ready" {
		rw.WriteHeader(http.StatusOK)
		return
	}

	rw.Header().Set("Content-Type", "text/event-stream; charset=utf-8")
	rw.Header().Set("Cache-Control", "no-cache")
	rw.Header().Set("Connection", "keep-alive")
	rw.WriteHeader(http.StatusOK)
	rw.Write([]byte("\n"))
	flusher := rw.(http.Flusher)
	flusher.Flush()

	closeNotifier := rw.(http.CloseNotifier).CloseNotify()

	for {
		select {
		case <-closeNotifier:
			return
		case message, ok := <-w.messages:
			if !ok {
				return
			}

			event := vitosse.Event{
				Data: message,
			}

			err := event.Write(rw)
			flusher.Flush()

			w.responses <- response{
				count: len(message),
				err:   err,
			}
		}
	}
}
Esempio n. 2
0
					w.WriteHeader(http.StatusOK)

					flusher.Flush()

					close(streaming)

					id := 0

					for e := range events {
						payload, err := json.Marshal(event.Message{Event: e})
						Expect(err).NotTo(HaveOccurred())

						event := sse.Event{
							ID:   fmt.Sprintf("%d", id),
							Name: "event",
							Data: payload,
						}

						err = event.Write(w)
						Expect(err).NotTo(HaveOccurred())

						flusher.Flush()

						id++
					}

					err := sse.Event{
						Name: "end",
					}.Write(w)
					Expect(err).NotTo(HaveOccurred())
Esempio n. 3
0
					Action: "Delete",
					Route: db.Route{
						Route:           "z.a.k",
						Port:            63,
						IP:              "42.42.42.42",
						TTL:             1,
						LogGuid:         "Tomato",
						RouteServiceUrl: "https://route-service-url.com",
					},
				}

				routeString, err := json.Marshal(event.Route)
				Expect(err).ToNot(HaveOccurred())

				sseEvent := sse.Event{
					Name: event.Action,
					Data: routeString,
				}

				headers := make(http.Header)
				headers.Set("Content-Type", "text/event-stream; charset=utf-8")

				command := buildCommand("events", flags, []string{})

				server.SetHandler(0,
					ghttp.CombineHandlers(
						ghttp.VerifyRequest("GET", "/v1/events"),
						ghttp.RespondWith(http.StatusOK, sseEvent.Encode(), headers),
					),
				)

				session := routeRegistrar(command...)
Esempio n. 4
0
				log := string(r)
				Expect(err).NotTo(HaveOccurred())
				Expect(log).To(ContainSubstring("REQUEST: "))
				Expect(log).To(ContainSubstring("GET /v1/routes HTTP/1.1"))

				Expect(log).To(ContainSubstring("RESPONSE: "))
				Expect(log).To(ContainSubstring("HTTP/1.1 400 Bad Request"))
				Expect(log).NotTo(ContainSubstring(string(expectedBody)))
			})
		})
	})

	Context("SubscribeToEvents", func() {
		var eventSource routing_api.EventSource
		var err error
		var event sse.Event

		BeforeEach(func() {
			data, _ := json.Marshal(route1)
			event = sse.Event{
				ID:   "1",
				Name: "Upsert",
				Data: data,
			}

			server.AppendHandlers(
				ghttp.CombineHandlers(
					ghttp.VerifyRequest("GET", "/v1/events"),
					ghttp.VerifyHeader(http.Header{
						"Authorization": []string{"bearer"},
					}),