Merge pull request #50 from 178inaba/streaming

Optimize streaming

cmd/mstdn/cmd_stream.go

@@ -80,7 +80,6 @@ func cmdStream(c *cli.Context) error {
 	go func() {
 		<-sc
 		cancel()
-		close(q)
 	}()
 
 	c.App.Metadata["signal"] = sc

streaming.go

@@ -8,8 +8,8 @@ import (
 	"net/http"
 	"net/url"
 	"path"
+	"strconv"
 	"strings"
-	"time"
 )
 
 // UpdateEvent is struct for passing status event to app.
@@ -42,8 +42,8 @@ type Event interface {
 	event()
 }
 
-func handleReader(ctx context.Context, q chan Event, r io.Reader) error {
-	name := ""
+func handleReader(q chan Event, r io.Reader) error {
+	var name string
 	s := bufio.NewScanner(r)
 	for s.Scan() {
 		line := s.Text()
@@ -55,30 +55,33 @@ func handleReader(ctx context.Context, q chan Event, r io.Reader) error {
 		case "event":
 			name = strings.TrimSpace(token[1])
 		case "data":
+			var err error
 			switch name {
 			case "update":
 				var status Status
-				err := json.Unmarshal([]byte(token[1]), &status)
+				err = json.Unmarshal([]byte(token[1]), &status)
 				if err == nil {
 					q <- &UpdateEvent{&status}
 				}
 			case "notification":
 				var notification Notification
-				err := json.Unmarshal([]byte(token[1]), &notification)
+				err = json.Unmarshal([]byte(token[1]), &notification)
 				if err == nil {
 					q <- &NotificationEvent{&notification}
 				}
 			case "delete":
 				var id int64
-				err := json.Unmarshal([]byte(token[1]), &id)
+				id, err = strconv.ParseInt(strings.TrimSpace(token[1]), 10, 64)
 				if err == nil {
 					q <- &DeleteEvent{id}
 				}
 			}
-		default:
+			if err != nil {
+				q <- &ErrorEvent{err}
 			}
 		}
-	return ctx.Err()
+	}
+	return s.Err()
 }
 
 func (c *Client) streaming(ctx context.Context, p string, params url.Values) (chan Event, error) {
@@ -96,38 +99,42 @@ func (c *Client) streaming(ctx context.Context, p string, params url.Values) (ch
 	req = req.WithContext(ctx)
 	req.Header.Set("Authorization", "Bearer "+c.config.AccessToken)
 
-	var resp *http.Response
-
-	q := make(chan Event, 10)
+	q := make(chan Event)
 	go func() {
-		defer ctx.Done()
-
+		defer close(q)
 		for {
-			resp, err = c.Do(req)
-			if resp != nil && resp.StatusCode != http.StatusOK {
-				err = parseAPIError("bad request", resp)
+			select {
+			case <-ctx.Done():
+				q <- &ErrorEvent{ctx.Err()}
+				return
+			default:
 			}
-			if err == nil {
-				err = handleReader(ctx, q, resp.Body)
-				if err == nil {
-					break
-				}
-			} else {
-				q <- &ErrorEvent{err}
-			}
-			resp.Body.Close()
-			time.Sleep(3 * time.Second)
-		}
-	}()
-	go func() {
-		<-ctx.Done()
-		if resp != nil && resp.Body != nil {
-			resp.Body.Close()
+
+			c.doStreaming(req, q)
 		}
 	}()
 	return q, nil
 }
 
+func (c *Client) doStreaming(req *http.Request, q chan Event) {
+	resp, err := c.Do(req)
+	if err != nil {
+		q <- &ErrorEvent{err}
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		q <- &ErrorEvent{parseAPIError("bad request", resp)}
+		return
+	}
+
+	err = handleReader(q, resp.Body)
+	if err != nil {
+		q <- &ErrorEvent{err}
+	}
+}
+
 // StreamingUser return channel to read events on home.
 func (c *Client) StreamingUser(ctx context.Context) (chan Event, error) {
 	return c.streaming(ctx, "user", nil)

streaming_test.go

@@ -5,13 +5,207 @@ import (
 	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
 	"time"
 )
 
-func TestStreamingPublic(t *testing.T) {
+func TestHandleReader(t *testing.T) {
+	q := make(chan Event)
+	r := strings.NewReader(`
+event: update
+data: {content: error}
+event: update
+data: {"content": "foo"}
+event: notification
+data: {"type": "mention"}
+event: delete
+data: 1234567
+:thump
+	`)
+	go func() {
+		defer close(q)
+		err := handleReader(q, r)
+		if err != nil {
+			t.Fatalf("should not be fail: %v", err)
+		}
+	}()
+	var passUpdate, passNotification, passDelete, passError bool
+	for e := range q {
+		switch event := e.(type) {
+		case *UpdateEvent:
+			passUpdate = true
+			if event.Status.Content != "foo" {
+				t.Fatalf("want %q but %q", "foo", event.Status.Content)
+			}
+		case *NotificationEvent:
+			passNotification = true
+			if event.Notification.Type != "mention" {
+				t.Fatalf("want %q but %q", "mention", event.Notification.Type)
+			}
+		case *DeleteEvent:
+			passDelete = true
+			if event.ID != 1234567 {
+				t.Fatalf("want %d but %d", 1234567, event.ID)
+			}
+		case *ErrorEvent:
+			passError = true
+			if event.err == nil {
+				t.Fatalf("should be fail: %v", event.err)
+			}
+		}
+	}
+	if !passUpdate || !passNotification || !passDelete || !passError {
+		t.Fatalf("have not passed through somewhere: "+
+			"update %t, notification %t, delete %t, error %t",
+			passUpdate, passNotification, passDelete, passError)
+	}
+}
+
+func TestStreaming(t *testing.T) {
+	var isEnd bool
+	canErr := true
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/api/v1/streaming/public" {
+		if isEnd {
+			return
+		} else if canErr {
+			canErr = false
+			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+			return
+		}
+		f := w.(http.Flusher)
+		fmt.Fprintln(w, `
+event: update
+data: {"content": "foo"}
+		`)
+		f.Flush()
+		isEnd = true
+	}))
+	defer ts.Close()
+
+	c := NewClient(&Config{Server: ":"})
+	_, err := c.streaming(context.Background(), "", nil)
+	if err == nil {
+		t.Fatalf("should be fail: %v", err)
+	}
+
+	c = NewClient(&Config{Server: ts.URL})
+	ctx, cancel := context.WithCancel(context.Background())
+	time.AfterFunc(time.Second, cancel)
+	q, err := c.streaming(ctx, "", nil)
+	if err != nil {
+		t.Fatalf("should not be fail: %v", err)
+	}
+	var cnt int
+	var passError, passUpdate bool
+	for e := range q {
+		switch event := e.(type) {
+		case *ErrorEvent:
+			passError = true
+			if event.err == nil {
+				t.Fatalf("should be fail: %v", event.err)
+			}
+		case *UpdateEvent:
+			cnt++
+			passUpdate = true
+			if event.Status.Content != "foo" {
+				t.Fatalf("want %q but %q", "foo", event.Status.Content)
+			}
+		}
+	}
+	if cnt != 1 {
+		t.Fatalf("result should be one: %d", cnt)
+	}
+	if !passError || !passUpdate {
+		t.Fatalf("have not passed through somewhere: error %t, update %t", passError, passUpdate)
+	}
+}
+
+func TestDoStreaming(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.(http.Flusher).Flush()
+		time.Sleep(time.Second)
+	}))
+	defer ts.Close()
+
+	c := NewClient(&Config{Server: ts.URL})
+
+	req, err := http.NewRequest(http.MethodGet, ts.URL, nil)
+	if err != nil {
+		t.Fatalf("should not be fail: %v", err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	time.AfterFunc(time.Millisecond, cancel)
+	req = req.WithContext(ctx)
+
+	q := make(chan Event)
+	go func() {
+		defer close(q)
+		c.doStreaming(req, q)
+		if err != nil {
+			t.Fatalf("should not be fail: %v", err)
+		}
+	}()
+	var passError bool
+	for e := range q {
+		if event, ok := e.(*ErrorEvent); ok {
+			passError = true
+			if event.err == nil {
+				t.Fatalf("should be fail: %v", event.err)
+			}
+		}
+	}
+	if !passError {
+		t.Fatalf("have not passed through: error %t", passError)
+	}
+}
+
+func TestStreamingUser(t *testing.T) {
+	var isEnd bool
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if isEnd {
+			return
+		} else if r.URL.Path != "/api/v1/streaming/user" {
+			http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
+			return
+		}
+		f, _ := w.(http.Flusher)
+		fmt.Fprintln(w, `
+event: update
+data: {"content": "foo"}
+		`)
+		f.Flush()
+		isEnd = true
+	}))
+	defer ts.Close()
+
+	c := NewClient(&Config{Server: ts.URL})
+	ctx, cancel := context.WithCancel(context.Background())
+	time.AfterFunc(time.Second, cancel)
+	q, err := c.StreamingUser(ctx)
+	if err != nil {
+		t.Fatalf("should not be fail: %v", err)
+	}
+	events := []Event{}
+	for e := range q {
+		if _, ok := e.(*ErrorEvent); !ok {
+			events = append(events, e)
+		}
+	}
+	if len(events) != 1 {
+		t.Fatalf("result should be one: %d", len(events))
+	}
+	if events[0].(*UpdateEvent).Status.Content != "foo" {
+		t.Fatalf("want %q but %q", "foo", events[0].(*UpdateEvent).Status.Content)
+	}
+}
+
+func TestStreamingPublic(t *testing.T) {
+	var isEnd bool
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if isEnd {
+			return
+		} else if r.URL.Path != "/api/v1/streaming/public/local" {
 			http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
 			return
 		}
@@ -27,7 +221,7 @@ event: update
 data: {"content": "bar"}
 		`)
 		f.Flush()
-		return
+		isEnd = true
 	}))
 	defer ts.Close()
 
@@ -38,18 +232,17 @@ data: {"content": "bar"}
 		AccessToken:  "zoo",
 	})
 	ctx, cancel := context.WithCancel(context.Background())
-	q, err := client.StreamingPublic(ctx, false)
+	q, err := client.StreamingPublic(ctx, true)
 	if err != nil {
 		t.Fatalf("should not be fail: %v", err)
 	}
-	time.AfterFunc(3*time.Second, func() {
-		cancel()
-		close(q)
-	})
+	time.AfterFunc(time.Second, cancel)
 	events := []Event{}
 	for e := range q {
+		if _, ok := e.(*ErrorEvent); !ok {
 			events = append(events, e)
 		}
+	}
 	if len(events) != 2 {
 		t.Fatalf("result should be two: %d", len(events))
 	}
@@ -60,3 +253,43 @@ data: {"content": "bar"}
 		t.Fatalf("want %q but %q", "bar", events[1].(*UpdateEvent).Status.Content)
 	}
 }
+
+func TestStreamingHashtag(t *testing.T) {
+	var isEnd bool
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if isEnd {
+			return
+		} else if r.URL.Path != "/api/v1/streaming/hashtag/local" {
+			http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
+			return
+		}
+		f, _ := w.(http.Flusher)
+		fmt.Fprintln(w, `
+event: update
+data: {"content": "foo"}
+		`)
+		f.Flush()
+		isEnd = true
+	}))
+	defer ts.Close()
+
+	client := NewClient(&Config{Server: ts.URL})
+	ctx, cancel := context.WithCancel(context.Background())
+	time.AfterFunc(time.Second, cancel)
+	q, err := client.StreamingHashtag(ctx, "hashtag", true)
+	if err != nil {
+		t.Fatalf("should not be fail: %v", err)
+	}
+	events := []Event{}
+	for e := range q {
+		if _, ok := e.(*ErrorEvent); !ok {
+			events = append(events, e)
+		}
+	}
+	if len(events) != 1 {
+		t.Fatalf("result should be one: %d", len(events))
+	}
+	if events[0].(*UpdateEvent).Status.Content != "foo" {
+		t.Fatalf("want %q but %q", "foo", events[0].(*UpdateEvent).Status.Content)
+	}
+}