pax_global_header00006660000000000000000000000064134747624350014531gustar00rootroot0000000000000052 comment=54d8467d122d380a14768b6b4e5cd7ca4755938f sse-0.1.0/000077500000000000000000000000001347476243500123215ustar00rootroot00000000000000sse-0.1.0/.travis.yml000066400000000000000000000005451347476243500144360ustar00rootroot00000000000000language: go sudo: false go: - 1.8.x - 1.9.x - 1.10.x - 1.11.x - 1.12.x - master git: depth: 10 matrix: fast_finish: true include: - go: 1.11.x env: GO111MODULE=on - go: 1.12.x env: GO111MODULE=on script: - go test -v -covermode=count -coverprofile=coverage.out after_success: - bash <(curl -s https://codecov.io/bash) sse-0.1.0/LICENSE000066400000000000000000000021031347476243500133220ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2014 Manuel Martínez-Almeida Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. sse-0.1.0/README.md000066400000000000000000000033201347476243500135760ustar00rootroot00000000000000# Server-Sent Events [![GoDoc](https://godoc.org/github.com/gin-contrib/sse?status.svg)](https://godoc.org/github.com/gin-contrib/sse) [![Build Status](https://travis-ci.org/gin-contrib/sse.svg)](https://travis-ci.org/gin-contrib/sse) [![codecov](https://codecov.io/gh/gin-contrib/sse/branch/master/graph/badge.svg)](https://codecov.io/gh/gin-contrib/sse) [![Go Report Card](https://goreportcard.com/badge/github.com/gin-contrib/sse)](https://goreportcard.com/report/github.com/gin-contrib/sse) Server-sent events (SSE) is a technology where a browser receives automatic updates from a server via HTTP connection. The Server-Sent Events EventSource API is [standardized as part of HTML5[1] by the W3C](http://www.w3.org/TR/2009/WD-eventsource-20091029/). - [Read this great SSE introduction by the HTML5Rocks guys](http://www.html5rocks.com/en/tutorials/eventsource/basics/) - [Browser support](http://caniuse.com/#feat=eventsource) ## Sample code ```go import "github.com/gin-contrib/sse" func httpHandler(w http.ResponseWriter, req *http.Request) { // data can be a primitive like a string, an integer or a float sse.Encode(w, sse.Event{ Event: "message", Data: "some data\nmore data", }) // also a complex type, like a map, a struct or a slice sse.Encode(w, sse.Event{ Id: "124", Event: "message", Data: map[string]interface{}{ "user": "manu", "date": time.Now().Unix(), "content": "hi!", }, }) } ``` ``` event: message data: some data\\nmore data id: 124 event: message data: {"content":"hi!","date":1431540810,"user":"manu"} ``` ## Content-Type ```go fmt.Println(sse.ContentType) ``` ``` text/event-stream ``` ## Decoding support There is a client-side implementation of SSE coming soon. sse-0.1.0/go.mod000066400000000000000000000001271347476243500134270ustar00rootroot00000000000000module github.com/gin-contrib/sse go 1.12 require github.com/stretchr/testify v1.3.0 sse-0.1.0/go.sum000066400000000000000000000011401347476243500134500ustar00rootroot00000000000000github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= sse-0.1.0/sse-decoder.go000066400000000000000000000072321347476243500150510ustar00rootroot00000000000000// Copyright 2014 Manu Martinez-Almeida. All rights reserved. // Use of this source code is governed by a MIT style // license that can be found in the LICENSE file. package sse import ( "bytes" "io" "io/ioutil" ) type decoder struct { events []Event } func Decode(r io.Reader) ([]Event, error) { var dec decoder return dec.decode(r) } func (d *decoder) dispatchEvent(event Event, data string) { dataLength := len(data) if dataLength > 0 { //If the data buffer's last character is a U+000A LINE FEED (LF) character, then remove the last character from the data buffer. data = data[:dataLength-1] dataLength-- } if dataLength == 0 && event.Event == "" { return } if event.Event == "" { event.Event = "message" } event.Data = data d.events = append(d.events, event) } func (d *decoder) decode(r io.Reader) ([]Event, error) { buf, err := ioutil.ReadAll(r) if err != nil { return nil, err } var currentEvent Event var dataBuffer *bytes.Buffer = new(bytes.Buffer) // TODO (and unit tests) // Lines must be separated by either a U+000D CARRIAGE RETURN U+000A LINE FEED (CRLF) character pair, // a single U+000A LINE FEED (LF) character, // or a single U+000D CARRIAGE RETURN (CR) character. lines := bytes.Split(buf, []byte{'\n'}) for _, line := range lines { if len(line) == 0 { // If the line is empty (a blank line). Dispatch the event. d.dispatchEvent(currentEvent, dataBuffer.String()) // reset current event and data buffer currentEvent = Event{} dataBuffer.Reset() continue } if line[0] == byte(':') { // If the line starts with a U+003A COLON character (:), ignore the line. continue } var field, value []byte colonIndex := bytes.IndexRune(line, ':') if colonIndex != -1 { // If the line contains a U+003A COLON character character (:) // Collect the characters on the line before the first U+003A COLON character (:), // and let field be that string. field = line[:colonIndex] // Collect the characters on the line after the first U+003A COLON character (:), // and let value be that string. value = line[colonIndex+1:] // If value starts with a single U+0020 SPACE character, remove it from value. if len(value) > 0 && value[0] == ' ' { value = value[1:] } } else { // Otherwise, the string is not empty but does not contain a U+003A COLON character character (:) // Use the whole line as the field name, and the empty string as the field value. field = line value = []byte{} } // The steps to process the field given a field name and a field value depend on the field name, // as given in the following list. Field names must be compared literally, // with no case folding performed. switch string(field) { case "event": // Set the event name buffer to field value. currentEvent.Event = string(value) case "id": // Set the event stream's last event ID to the field value. currentEvent.Id = string(value) case "retry": // If the field value consists of only characters in the range U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9), // then interpret the field value as an integer in base ten, and set the event stream's reconnection time to that integer. // Otherwise, ignore the field. currentEvent.Id = string(value) case "data": // Append the field value to the data buffer, dataBuffer.Write(value) // then append a single U+000A LINE FEED (LF) character to the data buffer. dataBuffer.WriteString("\n") default: //Otherwise. The field is ignored. continue } } // Once the end of the file is reached, the user agent must dispatch the event one final time. d.dispatchEvent(currentEvent, dataBuffer.String()) return d.events, nil } sse-0.1.0/sse-decoder_test.go000066400000000000000000000041401347476243500161030ustar00rootroot00000000000000// Copyright 2014 Manu Martinez-Almeida. All rights reserved. // Use of this source code is governed by a MIT style // license that can be found in the LICENSE file. package sse import ( "bytes" "testing" "github.com/stretchr/testify/assert" ) func TestDecodeSingle1(t *testing.T) { events, err := Decode(bytes.NewBufferString( `data: this is a text event: message fake: id: 123456789010 : we can append data : and multiple comments should not break it data: a very nice one`)) assert.NoError(t, err) assert.Len(t, events, 1) assert.Equal(t, events[0].Event, "message") assert.Equal(t, events[0].Id, "123456789010") } func TestDecodeSingle2(t *testing.T) { events, err := Decode(bytes.NewBufferString( `: starting with a comment fake: data:this is a \ntext event:a message\n\n fake :and multiple comments\n should not break it\n\n id:1234567890\n10 :we can append data data:a very nice one\n! `)) assert.NoError(t, err) assert.Len(t, events, 1) assert.Equal(t, events[0].Event, "a message\\n\\n") assert.Equal(t, events[0].Id, "1234567890\\n10") } func TestDecodeSingle3(t *testing.T) { events, err := Decode(bytes.NewBufferString( ` id:123456ABCabc789010 event: message123 : we can append data data:this is a text data: a very nice one data: data : ending with a comment`)) assert.NoError(t, err) assert.Len(t, events, 1) assert.Equal(t, events[0].Event, "message123") assert.Equal(t, events[0].Id, "123456ABCabc789010") } func TestDecodeMulti1(t *testing.T) { events, err := Decode(bytes.NewBufferString( ` id: event: weird event data:this is a text :data: this should NOT APER data: second line : a comment event: message id:123 data:this is a text :data: this should NOT APER data: second line : a comment event: message id:123 data:this is a text data: second line :hola data event: id`)) assert.NoError(t, err) assert.Len(t, events, 3) assert.Equal(t, events[0].Event, "weird event") assert.Equal(t, events[0].Id, "") } func TestDecodeW3C(t *testing.T) { events, err := Decode(bytes.NewBufferString( `data data data data: `)) assert.NoError(t, err) assert.Len(t, events, 1) } sse-0.1.0/sse-encoder.go000066400000000000000000000043201347476243500150560ustar00rootroot00000000000000// Copyright 2014 Manu Martinez-Almeida. All rights reserved. // Use of this source code is governed by a MIT style // license that can be found in the LICENSE file. package sse import ( "encoding/json" "fmt" "io" "net/http" "reflect" "strconv" "strings" ) // Server-Sent Events // W3C Working Draft 29 October 2009 // http://www.w3.org/TR/2009/WD-eventsource-20091029/ const ContentType = "text/event-stream" var contentType = []string{ContentType} var noCache = []string{"no-cache"} var fieldReplacer = strings.NewReplacer( "\n", "\\n", "\r", "\\r") var dataReplacer = strings.NewReplacer( "\n", "\ndata:", "\r", "\\r") type Event struct { Event string Id string Retry uint Data interface{} } func Encode(writer io.Writer, event Event) error { w := checkWriter(writer) writeId(w, event.Id) writeEvent(w, event.Event) writeRetry(w, event.Retry) return writeData(w, event.Data) } func writeId(w stringWriter, id string) { if len(id) > 0 { w.WriteString("id:") fieldReplacer.WriteString(w, id) w.WriteString("\n") } } func writeEvent(w stringWriter, event string) { if len(event) > 0 { w.WriteString("event:") fieldReplacer.WriteString(w, event) w.WriteString("\n") } } func writeRetry(w stringWriter, retry uint) { if retry > 0 { w.WriteString("retry:") w.WriteString(strconv.FormatUint(uint64(retry), 10)) w.WriteString("\n") } } func writeData(w stringWriter, data interface{}) error { w.WriteString("data:") switch kindOfData(data) { case reflect.Struct, reflect.Slice, reflect.Map: err := json.NewEncoder(w).Encode(data) if err != nil { return err } w.WriteString("\n") default: dataReplacer.WriteString(w, fmt.Sprint(data)) w.WriteString("\n\n") } return nil } func (r Event) Render(w http.ResponseWriter) error { r.WriteContentType(w) return Encode(w, r) } func (r Event) WriteContentType(w http.ResponseWriter) { header := w.Header() header["Content-Type"] = contentType if _, exist := header["Cache-Control"]; !exist { header["Cache-Control"] = noCache } } func kindOfData(data interface{}) reflect.Kind { value := reflect.ValueOf(data) valueType := value.Kind() if valueType == reflect.Ptr { valueType = value.Elem().Kind() } return valueType } sse-0.1.0/sse_test.go000066400000000000000000000123521347476243500145040ustar00rootroot00000000000000// Copyright 2014 Manu Martinez-Almeida. All rights reserved. // Use of this source code is governed by a MIT style // license that can be found in the LICENSE file. package sse import ( "bytes" "net/http/httptest" "testing" "github.com/stretchr/testify/assert" ) func TestEncodeOnlyData(t *testing.T) { w := new(bytes.Buffer) event := Event{ Data: "junk\n\njk\nid:fake", } err := Encode(w, event) assert.NoError(t, err) assert.Equal(t, w.String(), `data:junk data: data:jk data:id:fake `) decoded, _ := Decode(w) assert.Equal(t, "message", decoded[0].Event) assert.Equal(t, decoded[0].Data, []Event{event}[0].Data) } func TestEncodeWithEvent(t *testing.T) { w := new(bytes.Buffer) event := Event{ Event: "t\n:<>\r\test", Data: "junk\n\njk\nid:fake", } err := Encode(w, event) assert.NoError(t, err) assert.Equal(t, w.String(), `event:t\n:<>\r est data:junk data: data:jk data:id:fake `) decoded, _ := Decode(w) assert.Equal(t, "t\\n:<>\\r\test", decoded[0].Event) assert.Equal(t, decoded[0].Data, []Event{event}[0].Data) } func TestEncodeWithId(t *testing.T) { w := new(bytes.Buffer) err := Encode(w, Event{ Id: "t\n:<>\r\test", Data: "junk\n\njk\nid:fa\rke", }) assert.NoError(t, err) assert.Equal(t, w.String(), `id:t\n:<>\r est data:junk data: data:jk data:id:fa\rke `) } func TestEncodeWithRetry(t *testing.T) { w := new(bytes.Buffer) err := Encode(w, Event{ Retry: 11, Data: "junk\n\njk\nid:fake\n", }) assert.NoError(t, err) assert.Equal(t, w.String(), `retry:11 data:junk data: data:jk data:id:fake data: `) } func TestEncodeWithEverything(t *testing.T) { w := new(bytes.Buffer) err := Encode(w, Event{ Event: "abc", Id: "12345", Retry: 10, Data: "some data", }) assert.NoError(t, err) assert.Equal(t, w.String(), "id:12345\nevent:abc\nretry:10\ndata:some data\n\n") } func TestEncodeMap(t *testing.T) { w := new(bytes.Buffer) err := Encode(w, Event{ Event: "a map", Data: map[string]interface{}{ "foo": "b\n\rar", "bar": "id: 2", }, }) assert.NoError(t, err) assert.Equal(t, w.String(), "event:a map\ndata:{\"bar\":\"id: 2\",\"foo\":\"b\\n\\rar\"}\n\n") } func TestEncodeSlice(t *testing.T) { w := new(bytes.Buffer) err := Encode(w, Event{ Event: "a slice", Data: []interface{}{1, "text", map[string]interface{}{"foo": "bar"}}, }) assert.NoError(t, err) assert.Equal(t, w.String(), "event:a slice\ndata:[1,\"text\",{\"foo\":\"bar\"}]\n\n") } func TestEncodeStruct(t *testing.T) { myStruct := struct { A int B string `json:"value"` }{1, "number"} w := new(bytes.Buffer) err := Encode(w, Event{ Event: "a struct", Data: myStruct, }) assert.NoError(t, err) assert.Equal(t, w.String(), "event:a struct\ndata:{\"A\":1,\"value\":\"number\"}\n\n") w.Reset() err = Encode(w, Event{ Event: "a struct", Data: &myStruct, }) assert.NoError(t, err) assert.Equal(t, w.String(), "event:a struct\ndata:{\"A\":1,\"value\":\"number\"}\n\n") } func TestEncodeInteger(t *testing.T) { w := new(bytes.Buffer) err := Encode(w, Event{ Event: "an integer", Data: 1, }) assert.NoError(t, err) assert.Equal(t, w.String(), "event:an integer\ndata:1\n\n") } func TestEncodeFloat(t *testing.T) { w := new(bytes.Buffer) err := Encode(w, Event{ Event: "Float", Data: 1.5, }) assert.NoError(t, err) assert.Equal(t, w.String(), "event:Float\ndata:1.5\n\n") } func TestEncodeStream(t *testing.T) { w := new(bytes.Buffer) Encode(w, Event{ Event: "float", Data: 1.5, }) Encode(w, Event{ Id: "123", Data: map[string]interface{}{"foo": "bar", "bar": "foo"}, }) Encode(w, Event{ Id: "124", Event: "chat", Data: "hi! dude", }) assert.Equal(t, w.String(), "event:float\ndata:1.5\n\nid:123\ndata:{\"bar\":\"foo\",\"foo\":\"bar\"}\n\nid:124\nevent:chat\ndata:hi! dude\n\n") } func TestRenderSSE(t *testing.T) { w := httptest.NewRecorder() err := (Event{ Event: "msg", Data: "hi! how are you?", }).Render(w) assert.NoError(t, err) assert.Equal(t, w.Body.String(), "event:msg\ndata:hi! how are you?\n\n") assert.Equal(t, w.Header().Get("Content-Type"), "text/event-stream") assert.Equal(t, w.Header().Get("Cache-Control"), "no-cache") } func BenchmarkResponseWriter(b *testing.B) { w := httptest.NewRecorder() b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { (Event{ Event: "new_message", Data: "hi! how are you? I am fine. this is a long stupid message!!!", }).Render(w) } } func BenchmarkFullSSE(b *testing.B) { buf := new(bytes.Buffer) b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { Encode(buf, Event{ Event: "new_message", Id: "13435", Retry: 10, Data: "hi! how are you? I am fine. this is a long stupid message!!!", }) buf.Reset() } } func BenchmarkNoRetrySSE(b *testing.B) { buf := new(bytes.Buffer) b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { Encode(buf, Event{ Event: "new_message", Id: "13435", Data: "hi! how are you? I am fine. this is a long stupid message!!!", }) buf.Reset() } } func BenchmarkSimpleSSE(b *testing.B) { buf := new(bytes.Buffer) b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { Encode(buf, Event{ Event: "new_message", Data: "hi! how are you? I am fine. this is a long stupid message!!!", }) buf.Reset() } } sse-0.1.0/writer.go000066400000000000000000000006131347476243500141640ustar00rootroot00000000000000package sse import "io" type stringWriter interface { io.Writer WriteString(string) (int, error) } type stringWrapper struct { io.Writer } func (w stringWrapper) WriteString(str string) (int, error) { return w.Writer.Write([]byte(str)) } func checkWriter(writer io.Writer) stringWriter { if w, ok := writer.(stringWriter); ok { return w } else { return stringWrapper{writer} } }