aboutsummaryrefslogtreecommitdiff
path: root/README
blob: eeff1e1abe014c1ed6dfc597a80a564316573f56 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
Pollymer
--------
Date: April 12th, 2013
Authors: Justin Karneges <justin@fanout.io>
         Katsuyuki Ohmuro <harmony7@pex2.jp>
Mailing List: http://lists.fanout.io/listinfo.cgi/fanout-users-fanout.io

Pollymer is a general-purpose AJAX library that provides conveniences for
long-polling applications, such as request retries, exponential backoff
between requests, randomized request delaying, and workarounds for browser
"busy" indications. It also implements multiple transports to ensure
cross-domain access works in all major browsers.

Dependencies:

  json2.js

Available Transports:

  XmlHttpRequest - for same-origin requests on all browsers, and cross-origin
    requests on modern CORS browsers
  JSON-P - for cross-origin requests on older non-CORS browsers such as IE7,
    IE8, IE9, and Opera < 12.00

Limitations:

  - If the JSON-P transport is used, the request headers and body are subject
    to URI length limitations of the browser and server.
  - If the JSON-P transport is used, it may not be possible to inspect all of
    the response headers. At most, the server may provide "noteworthy" headers
    within the JSON-P encoding.

Usage:

  var req = new Pollymer.Request();
  req.on('finished', function(code, result, headers) { ... });
  req.on('error', function(reason) { ... });
  var headers = { ... };
  var body = 'some data';
  req.maxTries = 2; // try twice
  req.start('POST', 'http://example.com/path', headers, body);

Methods of Request Object:

  on(event_name, callback) - Add callback for event:
    event_name: name of event
    callback:   method to call when event occurs

    available events:
      'finished': function(code, result, headers)
        code:    HTTP status code
        result:  JSON object or string
        headers: hash of key/value strings
      'error': function(reason)
        reason: Pollymer.errorType

  off(event_name) - Remove callback for event

  start(method, url, headers, body) - start request
    method:  name of method (e.g. 'GET')
    url:     string url, or function that returns a string url if called
    headers: hash of key/value strings (optional)
    body:    string body data (optional)

    Sometime after the request has been started, a finished or error event
    will be raised and the object will return to inactive state (unless the
    recurring flag is set, see below).

    The start method may be called again once the request has completed
    (unless the recurring flag is set, see below). If called again on the same
    object, a short random delay will be added before performing the request.

  retry() - Attempt the exact same request again. Normally, Pollymer will
    automatically retry a request that it considers to be a failure, but this
    method may be used if the application needs to retry the request for any
    another reason. Retries have an exponentially increasing delay between
    them. Do not use retry() if the previous request attempt was considered to
    be successful, as it will add penalizing delays that you probably don't
    want in that case.

  abort() - Stop any current request and return the object to inactive state.

Properties of Request Object:

  Properties are simple members of the object. They can be set directly:
    req.rawResponse = true;
  or passed in a hash during construction:
    var req = new Pollymer.Request({rawResponse: true});

  rawResponse: boolean
    By default, this library will parse response body data as JSON and return
    an object to the application. Set the rawResponse property to true to
    disable this behavior and have a string returned instead.

  maxTries: int
    The number of tries a request should be attempted with temporary failure
    before raising an error event. Set to -1 to indicate infinite attempts.
    Default is 1.

  maxDelay: int
    The maximum amount of random milliseconds to delay between requests.
    Default 1000.

  recurring: boolean
    If set to true, then after a request finishes with a code between 200 and
    299, and the finished event has been raised, the same request will be
    started again. This allows Pollymer to automatically poll a resource
    endlessly. Pass a function as the url argument in order to be able to
    change the url between polls.

  transport: Pollymer.transportType
    Explicitly set the transport to use. Default is transportType.Auto, which
    automatically chooses the best transport when the request is started.

  withCredentials: boolean
    If set to true, and the request will be a cross-origin request performed
    over an XmlHttpRequest transport using CORS, then the withCredentials flag
    will be set on the XmlHttpRequest object to be used.  Use this flag if the
    CORS request needs to have HTTP Cookies and/or HTTP Authentication
    information sent along with it.

  timeout: integer
    Request wait timeout in milliseconds.
    Default 60000.

Retries:

  When a request fails at the transport level, or the request succeeds with an
  error code between 500 and 599, and maxTries has not been reached, then
  Pollymer will retry the request silently, with an exponentially increasing
  delay between attempts. In any other case, the request will succeed and
  the finished event will be raised. If the application determines that the
  response indicates a temporary error and should be retried with the same
  backoff delay that Pollymer normally uses, the retry() method may be used.

Request Reuse:

  If start() is called on an object that has completed a request and is now
  inactive, then a random delay will be added before performing the next
  request. This is ideal behavior when repeatedly polling a resource, so do
  try to reuse the request object rather than throwing it away and creating a
  new one every time. When the recurring flag is used, the effect is the same
  as if you had called start() again yourself after a request finished.

  Be sure to recognize the difference between a retry and a reuse of the
  object. A retry implies that the previous request attempt was a failure,
  whereas reusing the object means the previous request attempt was
  successful. This distinction is important because it changes the way the
  delaying works.

JSON-P Protocol:

  This library supports JSON-P by supplying the following query string
  parameters in the request:

  callback: the JavaScript function to call in the response script
  _method: the method name (default GET)
  _headers: additional headers encoded as JSON (default none)
  _body: request body (default empty)

  This protocol dictates that the presence of the "callback" parameter
  signifies the request as a JSON-P request. The remaining parameters are
  optional.

  The server is expected to reply with a JSON object with fields:

  code: the HTTP response status code
  reason: the HTTP response reason phrase
  headers: any noteworthy HTTP response headers (default none)
  body: response body

  All fields are required except for "headers". Example response:

  {
    "code": 200,
    "reason": "OK",
    "headers": {
      "Content-Type": "application/json"
    },
    "body": "{ \"foo\": \"bar\" }"
  }