From 1b1589713592ec9d8f1945e4e61cac423e3e245e Mon Sep 17 00:00:00 2001 From: Wim Date: Wed, 2 Nov 2016 16:12:43 +0100 Subject: Fix tight loop (gitter). Closes #68. --- vendor/github.com/42wim/go-gitter/LICENSE | 201 ++++++++++++ vendor/github.com/42wim/go-gitter/faye.go | 70 ++++ vendor/github.com/42wim/go-gitter/gitter.go | 412 ++++++++++++++++++++++++ vendor/github.com/42wim/go-gitter/model.go | 142 ++++++++ vendor/github.com/42wim/go-gitter/stream.go | 221 +++++++++++++ vendor/github.com/42wim/go-gitter/test_utils.go | 30 ++ 6 files changed, 1076 insertions(+) create mode 100644 vendor/github.com/42wim/go-gitter/LICENSE create mode 100644 vendor/github.com/42wim/go-gitter/faye.go create mode 100644 vendor/github.com/42wim/go-gitter/gitter.go create mode 100644 vendor/github.com/42wim/go-gitter/model.go create mode 100644 vendor/github.com/42wim/go-gitter/stream.go create mode 100644 vendor/github.com/42wim/go-gitter/test_utils.go (limited to 'vendor/github.com/42wim/go-gitter') diff --git a/vendor/github.com/42wim/go-gitter/LICENSE b/vendor/github.com/42wim/go-gitter/LICENSE new file mode 100644 index 00000000..8dada3ed --- /dev/null +++ b/vendor/github.com/42wim/go-gitter/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/42wim/go-gitter/faye.go b/vendor/github.com/42wim/go-gitter/faye.go new file mode 100644 index 00000000..dcd3e210 --- /dev/null +++ b/vendor/github.com/42wim/go-gitter/faye.go @@ -0,0 +1,70 @@ +package gitter + +import ( + "encoding/json" + "fmt" + + "github.com/mrexodia/wray" +) + +type Faye struct { + endpoint string + Event chan Event + client *wray.FayeClient + gitter *Gitter +} + +func (gitter *Gitter) Faye(roomID string) *Faye { + wray.RegisterTransports([]wray.Transport{ + &wray.HttpTransport{ + SendHook: func(data map[string]interface{}) { + if channel, ok := data["channel"]; ok && channel == "/meta/handshake" { + data["ext"] = map[string]interface{}{"token": gitter.config.token} + } + }, + }, + }) + return &Faye{ + endpoint: "/api/v1/rooms/" + roomID + "/chatMessages", + Event: make(chan Event), + client: wray.NewFayeClient(fayeBaseURL), + gitter: gitter, + } +} + +func (faye *Faye) Listen() { + defer faye.destroy() + + faye.client.Subscribe(faye.endpoint, false, func(message wray.Message) { + dataBytes, err := json.Marshal(message.Data["model"]) + if err != nil { + fmt.Printf("JSON Marshal error: %v\n", err) + return + } + var gitterMessage Message + err = json.Unmarshal(dataBytes, &gitterMessage) + if err != nil { + fmt.Printf("JSON Unmarshal error: %v\n", err) + return + } + faye.Event <- Event{ + Data: &MessageReceived{ + Message: gitterMessage, + }, + } + }) + + //TODO: this might be needed in the future + /*go func() { + for { + faye.client.Publish("/api/v1/ping2", map[string]interface{}{"reason": "ping"}) + time.Sleep(60 * time.Second) + } + }()*/ + + faye.client.Listen() +} + +func (faye *Faye) destroy() { + close(faye.Event) +} diff --git a/vendor/github.com/42wim/go-gitter/gitter.go b/vendor/github.com/42wim/go-gitter/gitter.go new file mode 100644 index 00000000..af082881 --- /dev/null +++ b/vendor/github.com/42wim/go-gitter/gitter.go @@ -0,0 +1,412 @@ +// Package gitter is a Go client library for the Gitter API. +// +// Author: sromku +package gitter + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "io/ioutil" + "log" + "net/http" + "net/url" + "strconv" + "time" + + "github.com/mreiferson/go-httpclient" +) + +var ( + apiBaseURL = "https://api.gitter.im/v1/" + streamBaseURL = "https://stream.gitter.im/v1/" + fayeBaseURL = "https://ws.gitter.im/faye" +) + +type Gitter struct { + config struct { + apiBaseURL string + streamBaseURL string + token string + client *http.Client + } + debug bool + logWriter io.Writer +} + +// New initializes the Gitter API client +// +// For example: +// api := gitter.New("YOUR_ACCESS_TOKEN") +func New(token string) *Gitter { + + transport := &httpclient.Transport{ + ConnectTimeout: 5 * time.Second, + ReadWriteTimeout: 40 * time.Second, + } + defer transport.Close() + + s := &Gitter{} + s.config.apiBaseURL = apiBaseURL + s.config.streamBaseURL = streamBaseURL + s.config.token = token + s.config.client = &http.Client{ + Transport: transport, + } + return s +} + +// SetClient sets a custom http client. Can be useful in App Engine case. +func (gitter *Gitter) SetClient(client *http.Client) { + gitter.config.client = client +} + +// GetUser returns the current user +func (gitter *Gitter) GetUser() (*User, error) { + + var users []User + response, err := gitter.get(gitter.config.apiBaseURL + "user") + if err != nil { + gitter.log(err) + return nil, err + } + + err = json.Unmarshal(response, &users) + if err != nil { + gitter.log(err) + return nil, err + } + + if len(users) > 0 { + return &users[0], nil + } + + err = APIError{What: "Failed to retrieve current user"} + gitter.log(err) + return nil, err +} + +// GetUserRooms returns a list of Rooms the user is part of +func (gitter *Gitter) GetUserRooms(userID string) ([]Room, error) { + + var rooms []Room + response, err := gitter.get(gitter.config.apiBaseURL + "user/" + userID + "/rooms") + if err != nil { + gitter.log(err) + return nil, err + } + + err = json.Unmarshal(response, &rooms) + if err != nil { + gitter.log(err) + return nil, err + } + + return rooms, nil +} + +// GetRooms returns a list of rooms the current user is in +func (gitter *Gitter) GetRooms() ([]Room, error) { + + var rooms []Room + response, err := gitter.get(gitter.config.apiBaseURL + "rooms") + if err != nil { + gitter.log(err) + return nil, err + } + + err = json.Unmarshal(response, &rooms) + if err != nil { + gitter.log(err) + return nil, err + } + + return rooms, nil +} + +// GetRoom returns a room with the passed id +func (gitter *Gitter) GetRoom(roomID string) (*Room, error) { + + var room Room + response, err := gitter.get(gitter.config.apiBaseURL + "rooms/" + roomID) + if err != nil { + gitter.log(err) + return nil, err + } + + err = json.Unmarshal(response, &room) + if err != nil { + gitter.log(err) + return nil, err + } + + return &room, nil +} + +// GetMessages returns a list of messages in a room. +// Pagination is optional. You can pass nil or specific pagination params. +func (gitter *Gitter) GetMessages(roomID string, params *Pagination) ([]Message, error) { + + var messages []Message + url := gitter.config.apiBaseURL + "rooms/" + roomID + "/chatMessages" + if params != nil { + url += "?" + params.encode() + } + response, err := gitter.get(url) + if err != nil { + gitter.log(err) + return nil, err + } + + err = json.Unmarshal(response, &messages) + if err != nil { + gitter.log(err) + return nil, err + } + + return messages, nil +} + +// GetMessage returns a message in a room. +func (gitter *Gitter) GetMessage(roomID, messageID string) (*Message, error) { + + var message Message + response, err := gitter.get(gitter.config.apiBaseURL + "rooms/" + roomID + "/chatMessages/" + messageID) + if err != nil { + gitter.log(err) + return nil, err + } + + err = json.Unmarshal(response, &message) + if err != nil { + gitter.log(err) + return nil, err + } + + return &message, nil +} + +// SendMessage sends a message to a room +func (gitter *Gitter) SendMessage(roomID, text string) error { + + message := Message{Text: text} + body, _ := json.Marshal(message) + _, err := gitter.post(gitter.config.apiBaseURL+"rooms/"+roomID+"/chatMessages", body) + if err != nil { + gitter.log(err) + return err + } + + return nil +} + +// JoinRoom joins a room +func (gitter *Gitter) JoinRoom(roomID, userID string) (*Room, error) { + + message := Room{ID: roomID} + body, _ := json.Marshal(message) + response, err := gitter.post(gitter.config.apiBaseURL+"user/"+userID+"/rooms", body) + + if err != nil { + gitter.log(err) + return nil, err + } + + var room Room + err = json.Unmarshal(response, &room) + if err != nil { + gitter.log(err) + return nil, err + } + + return &room, nil +} + +// LeaveRoom removes a user from the room +func (gitter *Gitter) LeaveRoom(roomID, userID string) error { + + _, err := gitter.delete(gitter.config.apiBaseURL + "rooms/" + roomID + "/users/" + userID) + if err != nil { + gitter.log(err) + return err + } + + return nil +} + +// SetDebug traces errors if it's set to true. +func (gitter *Gitter) SetDebug(debug bool, logWriter io.Writer) { + gitter.debug = debug + gitter.logWriter = logWriter +} + +// Pagination params +type Pagination struct { + + // Skip n messages + Skip int + + // Get messages before beforeId + BeforeID string + + // Get messages after afterId + AfterID string + + // Maximum number of messages to return + Limit int + + // Search query + Query string +} + +func (messageParams *Pagination) encode() string { + values := url.Values{} + + if messageParams.AfterID != "" { + values.Add("afterId", messageParams.AfterID) + } + + if messageParams.BeforeID != "" { + values.Add("beforeId", messageParams.BeforeID) + } + + if messageParams.Skip > 0 { + values.Add("skip", strconv.Itoa(messageParams.Skip)) + } + + if messageParams.Limit > 0 { + values.Add("limit", strconv.Itoa(messageParams.Limit)) + } + + return values.Encode() +} + +func (gitter *Gitter) getResponse(url string, stream *Stream) (*http.Response, error) { + r, err := http.NewRequest("GET", url, nil) + if err != nil { + gitter.log(err) + return nil, err + } + r.Header.Set("Content-Type", "application/json") + r.Header.Set("Accept", "application/json") + r.Header.Set("Authorization", "Bearer "+gitter.config.token) + if stream != nil { + stream.streamConnection.request = r + } + response, err := gitter.config.client.Do(r) + if err != nil { + gitter.log(err) + return nil, err + } + return response, nil +} + +func (gitter *Gitter) get(url string) ([]byte, error) { + resp, err := gitter.getResponse(url, nil) + if err != nil { + gitter.log(err) + return nil, err + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + err = APIError{What: fmt.Sprintf("Status code: %v", resp.StatusCode)} + gitter.log(err) + return nil, err + } + + body, err := ioutil.ReadAll(resp.Body) + if err != nil { + gitter.log(err) + return nil, err + } + + return body, nil +} + +func (gitter *Gitter) post(url string, body []byte) ([]byte, error) { + r, err := http.NewRequest("POST", url, bytes.NewBuffer(body)) + if err != nil { + gitter.log(err) + return nil, err + } + + r.Header.Set("Content-Type", "application/json") + r.Header.Set("Accept", "application/json") + r.Header.Set("Authorization", "Bearer "+gitter.config.token) + + resp, err := gitter.config.client.Do(r) + if err != nil { + gitter.log(err) + return nil, err + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + err = APIError{What: fmt.Sprintf("Status code: %v", resp.StatusCode)} + gitter.log(err) + return nil, err + } + + result, err := ioutil.ReadAll(resp.Body) + if err != nil { + gitter.log(err) + return nil, err + } + + return result, nil +} + +func (gitter *Gitter) delete(url string) ([]byte, error) { + r, err := http.NewRequest("delete", url, nil) + if err != nil { + gitter.log(err) + return nil, err + } + + r.Header.Set("Content-Type", "application/json") + r.Header.Set("Accept", "application/json") + r.Header.Set("Authorization", "Bearer "+gitter.config.token) + + resp, err := gitter.config.client.Do(r) + if err != nil { + gitter.log(err) + return nil, err + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + err = APIError{What: fmt.Sprintf("Status code: %v", resp.StatusCode)} + gitter.log(err) + return nil, err + } + + result, err := ioutil.ReadAll(resp.Body) + if err != nil { + gitter.log(err) + return nil, err + } + + return result, nil +} + +func (gitter *Gitter) log(a interface{}) { + if gitter.debug { + log.Println(a) + if gitter.logWriter != nil { + timestamp := time.Now().Format(time.RFC3339) + msg := fmt.Sprintf("%v: %v", timestamp, a) + fmt.Fprintln(gitter.logWriter, msg) + } + } +} + +// APIError holds data of errors returned from the API. +type APIError struct { + What string +} + +func (e APIError) Error() string { + return fmt.Sprintf("%v", e.What) +} diff --git a/vendor/github.com/42wim/go-gitter/model.go b/vendor/github.com/42wim/go-gitter/model.go new file mode 100644 index 00000000..7a3d0729 --- /dev/null +++ b/vendor/github.com/42wim/go-gitter/model.go @@ -0,0 +1,142 @@ +package gitter + +import "time" + +// A Room in Gitter can represent a GitHub Organization, a GitHub Repository, a Gitter Channel or a One-to-one conversation. +// In the case of the Organizations and Repositories, the access control policies are inherited from GitHub. +type Room struct { + + // Room ID + ID string `json:"id"` + + // Room name + Name string `json:"name"` + + // Room topic. (default: GitHub repo description) + Topic string `json:"topic"` + + // Room URI on Gitter + URI string `json:"uri"` + + // Indicates if the room is a one-to-one chat + OneToOne bool `json:"oneToOne"` + + // Count of users in the room + UserCount int `json:"userCount"` + + // Number of unread messages for the current user + UnreadItems int `json:"unreadItems"` + + // Number of unread mentions for the current user + Mentions int `json:"mentions"` + + // Last time the current user accessed the room in ISO format + LastAccessTime time.Time `json:"lastAccessTime"` + + // Indicates if the current user has disabled notifications + Lurk bool `json:"lurk"` + + // Path to the room on gitter + URL string `json:"url"` + + // Type of the room + // - ORG: A room that represents a GitHub Organization. + // - REPO: A room that represents a GitHub Repository. + // - ONETOONE: A one-to-one chat. + // - ORG_CHANNEL: A Gitter channel nested under a GitHub Organization. + // - REPO_CHANNEL A Gitter channel nested under a GitHub Repository. + // - USER_CHANNEL A Gitter channel nested under a GitHub User. + GithubType string `json:"githubType"` + + // Tags that define the room + Tags []string `json:"tags"` + + RoomMember bool `json:"roomMember"` + + // Room version. + Version int `json:"v"` +} + +type User struct { + + // Gitter User ID + ID string `json:"id"` + + // Gitter/GitHub username + Username string `json:"username"` + + // Gitter/GitHub user real name + DisplayName string `json:"displayName"` + + // Path to the user on Gitter + URL string `json:"url"` + + // User avatar URI (small) + AvatarURLSmall string `json:"avatarUrlSmall"` + + // User avatar URI (medium) + AvatarURLMedium string `json:"avatarUrlMedium"` +} + +type Message struct { + + // ID of the message + ID string `json:"id"` + + // Original message in plain-text/markdown + Text string `json:"text"` + + // HTML formatted message + HTML string `json:"html"` + + // ISO formatted date of the message + Sent time.Time `json:"sent"` + + // ISO formatted date of the message if edited + EditedAt time.Time `json:"editedAt"` + + // User that sent the message + From User `json:"fromUser"` + + // Boolean that indicates if the current user has read the message. + Unread bool `json:"unread"` + + // Number of users that have read the message + ReadBy int `json:"readBy"` + + // List of URLs present in the message + Urls []URL `json:"urls"` + + // List of @Mentions in the message + Mentions []Mention `json:"mentions"` + + // List of #Issues referenced in the message + Issues []Issue `json:"issues"` + + // Version + Version int `json:"v"` +} + +// Mention holds data about mentioned user in the message +type Mention struct { + + // User's username + ScreenName string `json:"screenName"` + + // Gitter User ID + UserID string `json:"userID"` +} + +// Issue references issue in the message +type Issue struct { + + // Issue number + Number string `json:"number"` +} + +// URL presented in the message +type URL struct { + + // URL + URL string `json:"url"` +} diff --git a/vendor/github.com/42wim/go-gitter/stream.go b/vendor/github.com/42wim/go-gitter/stream.go new file mode 100644 index 00000000..4a5a3c68 --- /dev/null +++ b/vendor/github.com/42wim/go-gitter/stream.go @@ -0,0 +1,221 @@ +package gitter + +import ( + "bufio" + "encoding/json" + "fmt" + "net/http" + "time" + + "github.com/mreiferson/go-httpclient" +) + +var defaultConnectionWaitTime time.Duration = 3000 // millis +var defaultConnectionMaxRetries = 5 + +// Stream initialize stream +func (gitter *Gitter) Stream(roomID string) *Stream { + return &Stream{ + url: streamBaseURL + "rooms/" + roomID + "/chatMessages", + Event: make(chan Event), + gitter: gitter, + streamConnection: gitter.newStreamConnection( + defaultConnectionWaitTime, + defaultConnectionMaxRetries), + } +} + +// Implemented to conform with https://developer.gitter.im/docs/streaming-api +func (gitter *Gitter) Listen(stream *Stream) { + + defer stream.destroy() + + var reader *bufio.Reader + var gitterMessage Message + lastKeepalive := time.Now().Unix() + + // connect + stream.connect() + +Loop: + for { + + // if closed then stop trying + if stream.isClosed() { + stream.Event <- Event{ + Data: &GitterConnectionClosed{}, + } + break Loop + } + + resp := stream.getResponse() + if resp.StatusCode != 200 { + gitter.log(fmt.Sprintf("Unexpected response code %v", resp.StatusCode)) + continue + } + + //"The JSON stream returns messages as JSON objects that are delimited by carriage return (\r)" <- Not true crap it's (\n) only + reader = bufio.NewReader(resp.Body) + line, err := reader.ReadBytes('\n') + if err != nil { + gitter.log("ReadBytes error: " + err.Error()) + stream.connect() + continue + } + + //Check if the line only consists of whitespace + onlyWhitespace := true + for _, b := range line { + if b != ' ' && b != '\t' && b != '\r' && b != '\n' { + onlyWhitespace = false + } + } + + if onlyWhitespace { + //"Parsers must be tolerant of occasional extra newline characters placed between messages." + currentKeepalive := time.Now().Unix() //interesting behavior of 100+ keepalives per seconds was observed + if currentKeepalive-lastKeepalive > 10 { + lastKeepalive = currentKeepalive + gitter.log("Keepalive was received") + } + continue + } else if stream.isClosed() { + gitter.log("Stream closed") + continue + } + + // unmarshal the streamed data + err = json.Unmarshal(line, &gitterMessage) + if err != nil { + gitter.log("JSON Unmarshal error: " + err.Error()) + continue + } + + // we are here, then we got the good message. pipe it forward. + stream.Event <- Event{ + Data: &MessageReceived{ + Message: gitterMessage, + }, + } + } + + gitter.log("Listening was completed") +} + +// Stream holds stream data. +type Stream struct { + url string + Event chan Event + streamConnection *streamConnection + gitter *Gitter +} + +func (stream *Stream) destroy() { + close(stream.Event) +} + +type Event struct { + Data interface{} +} + +type GitterConnectionClosed struct { +} + +type MessageReceived struct { + Message Message +} + +// connect and try to reconnect with +func (stream *Stream) connect() { + + if stream.streamConnection.retries == stream.streamConnection.currentRetries { + stream.Close() + stream.gitter.log("Number of retries exceeded the max retries number, we are done here") + return + } + + res, err := stream.gitter.getResponse(stream.url, stream) + if stream.streamConnection.canceled { + // do nothing + } else if err != nil || res.StatusCode != 200 { + stream.gitter.log("Failed to get response, trying reconnect ") + stream.gitter.log(err) + + // sleep and wait + stream.streamConnection.currentRetries++ + time.Sleep(time.Millisecond * stream.streamConnection.wait * time.Duration(stream.streamConnection.currentRetries)) + + // connect again + stream.Close() + stream.connect() + } else { + stream.gitter.log("Response was received") + stream.streamConnection.currentRetries = 0 + stream.streamConnection.closed = false + stream.streamConnection.response = res + } +} + +type streamConnection struct { + + // connection was closed + closed bool + + // canceled + canceled bool + + // wait time till next try + wait time.Duration + + // max tries to recover + retries int + + // current streamed response + response *http.Response + + // current request + request *http.Request + + // current status + currentRetries int +} + +// Close the stream connection and stop receiving streamed data +func (stream *Stream) Close() { + conn := stream.streamConnection + conn.closed = true + if conn.response != nil { + stream.gitter.log("Stream connection close response") + defer conn.response.Body.Close() + } + if conn.request != nil { + stream.gitter.log("Stream connection close request") + switch transport := stream.gitter.config.client.Transport.(type) { + case *httpclient.Transport: + stream.streamConnection.canceled = true + transport.CancelRequest(conn.request) + default: + } + + } + conn.currentRetries = 0 +} + +func (stream *Stream) isClosed() bool { + return stream.streamConnection.closed +} + +func (stream *Stream) getResponse() *http.Response { + return stream.streamConnection.response +} + +// Optional, set stream connection properties +// wait - time in milliseconds of waiting between reconnections. Will grow exponentially. +// retries - number of reconnections retries before dropping the stream. +func (gitter *Gitter) newStreamConnection(wait time.Duration, retries int) *streamConnection { + return &streamConnection{ + closed: true, + wait: wait, + retries: retries, + } +} diff --git a/vendor/github.com/42wim/go-gitter/test_utils.go b/vendor/github.com/42wim/go-gitter/test_utils.go new file mode 100644 index 00000000..6703da2e --- /dev/null +++ b/vendor/github.com/42wim/go-gitter/test_utils.go @@ -0,0 +1,30 @@ +package gitter + +import ( + "net/http" + "net/http/httptest" + "net/url" +) + +var ( + mux *http.ServeMux + gitter *Gitter + server *httptest.Server +) + +func setup() { + mux = http.NewServeMux() + server = httptest.NewServer(mux) + + gitter = New("abc") + + // Fake the API and Stream base URLs by using the test + // server URL instead. + url, _ := url.Parse(server.URL) + gitter.config.apiBaseURL = url.String() + "/" + gitter.config.streamBaseURL = url.String() + "/" +} + +func teardown() { + server.Close() +} -- cgit v1.2.3