YUI 3: The IO Utility

IO Utility

Getting Started

Include Dependencies

To use IO Utility, include the following source files in your web page with the script tag:

<!-- Dependencies --> <script src="http://yui.yahooapis.com/3.0.0b1/build/yui/yui.js" type="text/javascript"></script> <!-- Source file --> <script src="http://yui.yahooapis.com/3.0.0b1/build/io.js" type="text/javascript"></script>

NOTE: Cross-domain transactions with IO require the use of io.swf. Make sure this dependency is deployed and accessible by io.js.

A Simple Transaction

io() is the primary method for making an HTTP request. This method accepts two arguments: uri and the configuration object.

• uri: This parameter specifies the URI for the transaction
• configuration: This parameter is an object of keys and values of configurations specific to the transaction. Please see: The Configuration Object for more information on all available configuration properties.

YUI.io returns an object with the following members:

• id: This is the unique identifier of the transaction.
• abort(): Aborts the specific transaction.
• isInProgress: A boolean value indicating whether the transaction has completed.

This is an example GET transaction, handling the response at the earliest opportunity.

// Create a YUI instance using IO module. YUI().use("io-base", function(Y) { var uri = "get.php?foo=bar"; // Define a function to handle the response data. function complete(id, o, args) { var id = id; // Transaction ID. var data = o.responseText; // Response data. var args = args[1]; // 'ipsum'. }; // Subscribe to event "io:complete", and pass an array // as an argument to the event handler "complete". Since // "complete" is global. // At this point in the transaction lifecycle, success or // failure is not yet know. Y.on('io:complete', complete, this, ['lorem', 'ipsum']); // Make an HTTP request to 'get.php'. // NOTE: This transaction does not use a configuration object. var request = Y.io(uri); } );

Using IO

This section describes how to use the IO Utility in further detail. It contains these subsections:

• Modules
• The Configuration Object
• Events
• Cross-Domain Requests
• Serializing HTML Forms as Data
• Uploading files in an HTML Form
• Setting HTTP Headers
• Queue

IO Modules

Beginning with PR2, IO's core and supplementary features are split into a base module and sub-modules, to allow greater flexibility in selecting the desired features.

Module	Description
io-base	This is the IO base class, containing the basic functionality needed for making HTTP requests.
io-xdr	This sub-module extends io-base, to add cross-domain request capabilities, using Flash as the transport.
io-form	This sub-module extends io-base, to add HTML form serialization, as transaction data.
io-upload-iframe	This sub-module extends io-base, to allow file uploads with an HTML form, using an iframe as the transport.
io-queue	This sub-module extends io-base, to provide a basic queue interface for IO.

The Configuration Object

This object is the second argument of io(). Its properties define transaction parameters and transaction response handling. The configuration object and all configuration properties are optional. The following table describes all configuration properties used by IO.

Property	Description
method (string)	Defines the HTTP method for the transaction. If this property is undefined or omitted, the default value is GET.
data (string)	Data to be sent with HTTP POST transactions. Data are sent as a string of key-value pairs (e.g., "foo=bar&baz=boo"). Note: Use JSON, instead of a key/value string with cross-domain(Flash transport) or file upload transactions.
headers (object)	Specific HTTP headers and values to be sent with the transaction (e.g., { 'Content-Type': 'application/xml; charset=utf-8' } ).
on (object)	This object defines the events and event handlers to be used for the transaction. These events fire in addition to the global IO events. Define as many events as desired for the transaction; all events handlers are optional. start: event handler complete: event handler success: event handler failure: event handler end: event handler NOTE: These events are accessible only to the transaction's subscribers, whereas global IO events are accessible by all subscribers.
context	Defines the execution context of the event handler functions for the transaction. If undefined, a default value of window is used.
form (object)	This object instructs IO to use the labels and values of the specified HTML form as data. id: This property can be defined as the id(String) of an HTML form or an object reference of the HTML form. useDisabled: When set to true, disabled field values are included as data. The default value is false.
xdr (object)	Defines the transport to be used for cross-domain requests (e.g., { use:'flash' } ). The transaction will use the specified transport instead of XMLHttpRequest, when specified in the transaction's configuration object. Currently, the only alternate transport supported is Flash, requiring Flash Player 9 (player 9.0.124 is recommended).
arguments (object)	Object, array, string, or number passed to all registered, transaction event handlers. This value is available as the second argument in the "start" and "end" event handlers; and, it is the third argument in the "complete", "success", and "failure" event handlers.
timeout	This value, defined as milliseconds, is a time threshold for the transaction (e.g., { timeout: 2000 } ). When this limit is reached, and the transaction's Complete event has not yet fired, the transaction will be aborted.

This is an example of a configuration object, with a set of properties defined.

/* * This is an example configuration object will all properties defined. * * method: This transaction will use HTTP POST. * data: "user=yahoo" is the POST data. * headers: Object of HTTP request headers for this transaction. The * first header defines "Content-Type" and the second is a * custom header. * on: Object of defined event handlers for "start", "complete", * and "end". These handlers are methods of an object * named "Dispatch". * context: Event handlers will execute in the propert object context, * so usage 'this' will reference Dispatch. * form: Object specifying the HTML form to be serialized into a key-value * string and sent as data; and, informing IO to include disabled * HTML form fields as part of the data. If input type of "file" * is present, setting the upload property to "true" will create an * alternate transport, to submit the HTML form with the * selected files. * xdr: Instructs IO to use the defined transport, in this case Flash, * to make a cross-domain request for this transaction. * arguments: Object of data, passed as an argument to the event * handlers. */ var cfg = { method: 'POST', data: 'user=yahoo', headers: { 'Content-Type': 'application/json', 'X-TRANSPORT-TYPE': 'Flash' }, on: { start: Dispatch.start, complete: Dispatch.complete, end: Dispatch.end } }, context: Dispatch, form: { id: formObject, useDisabled: true, upload: true }, xdr: { use: 'flash' }, arguments: { start: 'foo', complete: 'bar', end: 'baz' } };

The Response Object

When a transaction -- using the XHR object as a transport -- is complete, the response data are passed as an object to the event handler.

Field	Description
status	The HTTP status code of the transaction.
statusText	The HTTP status message.
getResponseHeader(headername)	Returns the string value of the specified header label.
getAllResponseHeaders	All response HTTP headers are available as a string. Each label-value pair is delimited by "\n".
responseText	The response data as a unicode string.
responseXML	The response data as an XML document object.

NOTE: Transactions involving file upload or cross-domain requests, using alternate transports, only populate the responseText field. The HTTP status and response headers are either inaccessible or unavailable to these alternate transports.

Events

IO events provide access to data during a transaction's lifecycle. There are two aspects to IO events: global and transaction. Global events are fired by IO for all transactions, and these events are accessible to all event subscribers. Transaction events are created and fired only if their event handlers are defined in the configuration object. Global events are identified by the io:eventname pattern. The following example describes the event subscription syntax for global events:

The following table describes the available IO events:

Event	Description
io:start	Fires when a request is made to a resource. The event handler's arguments signature is: function onStart(transactionid, arguments) { // transactionid : The transaction's ID. // arguments: Array ['foo','bar']. } // Subscribe to "io.start". Y.on('io:start', onStart, this, { start: ['foo','bar']; );
io:complete	Fires after "io:start", when the transaction is complete and response data are available. This is the earliest opportunity to access any response data. The event handler's arguments signature is: function onComplete(transactionid, response, arguments) { // transactionid : The transaction's ID. // response: The response object. // arguments: Object containing an array { complete: ['foo', 'bar'] }. } // Subscribe to "io.complete". Y.on('io:complete', onComplete, this, { complete: ['foo', 'bar'] } );
io:success	Fires after the "complete" event, when the response HTTP status resolves to 2xx. The event handler's arguments signature is: function onSuccess(transactionid, response, arguments) { // transactionid : The transaction's ID. // response: The response object. // arguments: Boolean "true". } // Subscribe to "io.success". Y.on('io:success', onSuccess, this, true);
io:failure	Fires after the "complete" event, when the response HTTP status resolves to 4xx. 5xx, or any undefined HTTP status. This event also includes abort and timeout conditions. The event handler's arguments signature is: function onFailure(transactionid, response, arguments) { // transactionid : The transaction's ID. // response: The response object. Only status and statusText // are populated when the transaction is terminated // due to abort or timeout. The status will read // 0, and statusText will return "timeout" or "abort" // depending on the mode of termination. // arguments: String "Transaction Failed". } // Subscribe to "io.failure". Y.on('io:failure', onFailure, this, 'Transaction Failed');
io:end	Fires at the conclusion of a transaction, after "success" or "failure" has been determined.. The event handler's arguments signature is: function onEnd(transactionid, arguments) { // transactionid : The transaction's ID. // arguments: Number 0. } // Subscribe to "io.end". Y.on('io:end', onEnd, this, 0);
io:xdrReady	Fires when the XDR transport is ready for use. This event only fires once, when the transport initialization is complete.

The following example demonstrates an IO transaction with an event handler subscribed to "io:complete".

// Create a YUI instance using IO module. YUI().use("io-base", function(Y) { /* * Create a function as the event handler for the event "io:complete". * * The function will receive the following arguments: * - The ID of the transaction * - Object containing the response data. * - Argument one defined when subscribing to the event(e.g., "foo"). * - Argument two defined when subscribing to the event(e.g., "bar"). */ function onComplete(transactionId, responseObject, arg1, arg2) { /* * The argument 'responseObject' is the response object. Its * properties are: * - status * - statusText * - getResponseHeader(headerName) * - getAllResponseHeaders * - responseText * - responseXML * * NOTE: In an XDR transaction, only the responseText property is defined. */ }; /* * Subscribe to the event "io:complete", using Y.on. * * - 'io:complete' : Subscribe to this IO event. * - onComplete : The event handler to be subscribed to 'io:complete'. * - this : The execution context of the event handler, in this case 'this' * since the doComplete is defined as a global function. * - 'foo' : The first argument received by the event handler. * - 'bar' : The second argument received by the event handler. * Additional arguments can be defined, as desired. */ Y.on('io:complete', onComplete, this, "foo", "bar"); // Starts the transaction. var request = Y.io(uri); }; );

Cross-Domain Transactions

By default, IO uses the XMLHttpRequest object as the transport for HTTP transactions. IO can also be instructed to use an alternate transport to make cross-domain, HTTP transactions. Currently, IO can make use of Flash as an alternate transport for such requests. To prepare IO for cross-domain transactions, the transport must be initialized and the file "io.swf" is deployed and accessible. For each transaction, the configuration object's xdr property must be defined with { use: 'flash' } so IO will use the designated transport, instead of using the default transport of XMLHttpRequest.

As io.swf is written in ActionScript 3, Flash Player 9 or better is required (version 9.0.124 or better is recommended). Additionally, a cross-domain policy file must be deployed at the resource to grant the client access to the remote domain. A cross-domain request will not be successful without this policy file hosted at the resource. The following example file grants permissive access to the host from all requests, but the host will only accept custom HTTP headers originating from yahoo.com.

<?xml version="1.0"?> <!DOCTYPE cross-domain-policy SYSTEM "http://www.adobe.com/xml/dtds/cross-domain-policy.dtd"> <cross-domain-policy> <allow-access-from domain="*"/> <allow-http-request-headers-from domain="*.yahoo.com" headers="*"/> </cross-domain-policy>

For more information on cross-domain policy file specifications, see the following articles at Adobe Developer Connection.

• Cross-Domain Policy File Specifications.
• HTTP Headers Blacklist.

The following example demonstrates a cross-domain transaction, starting with the initialization of the XDR transport, and subscribing to three global IO events.

// Create a YUI instance using the IO cross-domain submodule YUI().use("io-xdr", function(Y) { // Create a configuration object containing three defined properties: // id: Identifies the transport to be used. // yid: The ID of the YUI instance. // src: The path to the Flash file, relative to the HTML. var xdrCfg = { id:'flash', yid: Y.id, src:'io.swf' }; // Initialize the define transport Y.io.transport(xdrCfg); // Define the configurations to be used for each transaciton.. var cfg = { use: 'flash', // Instruct IO to use the XDR transport. data: { 'foo': 'bar' }, // For XDR transactions, the key-values must be expressed as JSON. timeout: 3000, // Abort the transaction, if it is still pending, after 3000ms. arguments: { start: 'foo', complete: 'bar', end: 'baz' } // An object passed, as an argument, to the event handlers. }; /* * GlobalEventHandler is an example object that encapsulates * event handlers for "io:start", "io:complete", and "io:end". * * start( ) // Event handler for "io:start" * complete( ) // Event handler for "io:complete". * end( ) // Event handler for "io:end". */ var GlobalEventHandler = { start: function(id, args) { var args = args.start // 'foo' }, complete: function(id, o, args) { var args = args.complete // 'bar' // Note: Only strings are supported in an XDR response. // o.responseXML is not supported at this time. var data = o.responseText; }, end: function(id, args) { var args = args.end // args = 'baz' } }; // Subscribe GlobalEventHandler.start to event "io:start". Y.on('io:start', GlobalEventHandler.start, this); // Subscribe GlobalEventHandler.complete to event "io:complete". Y.on('io:complete', GlobalEventHandler.complete, this); // Subscribe GlobalEventHandler to event "io:end". Y.on('io:end', GlobalEventHandler.end, this); // Start the transaction var request = Y.io(uri, cfg); } );

Serializing HTML Form as Data

IO can serialize HTML form fields into a string of encoded name-value pairs. If the transaction is HTTP GET, the data are appended to the URI as a querystring. If the transaction if HTTP POST, the data will be the POST message.

// Create a YUI instance using the IO form sub-module. YUI().use("io-form", function(Y) { // Create a configuration object for the file upload transaction. // The form configuration should include two defined properties: // id: This can be the ID or an object reference to the HTML form // containing the input type="file" elements. // useDisabled: Set this property to "true" to include disabled // HTML form fields, as part of the data. By // default, disabled fields are excluded from the // serialization. var cfg = { method: 'POST', form: { id: formObject, useDisabled: true } }; // Define a function to handle the response data. function complete(id, o, args) { var id = id; // Transaction ID. var data = o.responseText; // Response data. var args = args[1]; // 'ipsum'. }; // Subscribe to event "io:complete", and pass an array // as an argument to the event handler "complete". Y.on('io:complete', complete, this, { 'foo':'bar' }); // Start the transaction. var request = Y.io(uri, cfg); } );

Uploading Files in an HTML Form

The default XHR transport, used in IO, cannot upload HTML form data that includes elements of type="file". In this situation, IO will create an alternate transport, to facilitate the transaction. The following example shows how to configure a transaction involving file upload:

/* * This example demonstrates how to configure IO to upload files * from an HTML form. This example uses the global events: * "io:start" and "io:complete" to handle the transaction and * response. Transaction events can be defined and fired, as well, * in the configuration object; but, they are not used in this * example. */ // Create a YUI instance using the IO upload sub-module. YUI().use("io-upload-iframe", function(Y) { // Create a configuration object for the file upload transaction. // The form configuration should include two defined properties: // id: This can be the ID or an object reference to the HTML form // containing the input type="file" elements. // upload: Set this property to "true" to indicate this is a file // upload transaction. var cfg = { method: 'POST', form: { id: formObject, upload: true } }; // Define a function to handle the start of a transaction function start(id, args) { var id = id; // Transaction ID. var args = args.foo; // 'bar' } // Define a function to handle the response data. function complete(id, o, args) { var id = id; // Transaction ID. var data = o.responseText; // Response data. var args = args[1]; // 'ipsum'. }; // Subscribe to event "io:start", and pass an object // as an argument to the event handler "start". Y.on('io:start', start, this, { 'foo':'bar' }); // Subscribe to event "io:complete", and pass an array // as an argument to the event handler "complete". Y.on('io:complete', complete, this, ['lorem', 'ipsum']); // Start the transaction. var request = Y.io(uri, cfg); } );

When using the io-upload-iframe sub-module, to perform file upload transactions, only some events -- global and transaction -- will be processed and fired. Specifically, these are:

• Start
• Complete

Success and Failure events are not processed and fired because the iframe transport does not provide access to the HTTP status and response headers, to discern those states.

Setting HTTP Headers

IO can be configured to send default HTTP Headers for all transactions, in addition to any HTTP headers defined in the configuration object. Headers can be set or removed as needed. The following example shows how to set and how to delete default headers in IO:

YUI().use("io-base", function(Y) { // Set a new default HTTP header. Y.io.header('Content-Type', 'application/json'); // To remove an existing header, use the same method, but omit the value. Y.io.header('Content-Type'); } );

Queue

YUI io's queue implements YUI Queue to provide sychronous, transaction response. Specifically, transactions are handled -- by global or transaction event handlers -- in the order they are sent, regardless of actual server response order. Transactions can be promoted to the front of the queue, or they can be purged from the queue, as well.

Field	Description
queue(uri, configuration)	Method signature is identical to IO, but returns the id of the transaction.
queue.start()	Activates the queue, and begins processing transactions in the queue. This is the default state of the queue.
queue.stop()	Deactivates the queue. Transactions sent to queue() will be stored until the queue is re-started.
queue.promote(id)	Moves the specified transaction stored in the queue to the head of the queue.
queue.purge(id)	Deletes the specified transaction stored in the queue.

// Create a YUI instance using the IO queue sub-module. YUI().use("io-queue", function(Y) { // Stop the queue so transactions can be stored. Y.io.queue.stop(); // Send four transactions into the queue for storage. var task0 = Y.io.queue(uri); var task1 = Y.io.queue(uri); var task2 = Y.io.queue(uri); var task3 = Y.io.queue(uri); // Promote task2 to the top of the queue. Y.io.queue.promote(task2); // Purge task3 from the queue. Y.io.queue.purge(task3); // Re-start the queue. // Transactions are sent in the following order: task2, task0, task 1. // Transaction callbacks, if provided, will be processed in the same // sequence: task2, task0, task1, regardless of actual response order. // Y.io.queue.start(); } );

Known Issues

• HTTP POST transactions are set by Firefox 3.x, to use a "Content-Type" of "application/x-www-form-urlencoded; charset=UTF-8". This cannot be overwritten by defining a different value in the configuration object.
• Cross-domain requests
• Custom HTTP headers are only sent with HTTP POST. This is a Flash Player limitation.
• Only responseText is populated in the response object. HTTP status and HTTP response headers are not available. These data are not accessible by Flash Player, except in IE.
• XML response data are not supported.
• IE 6 and 7 will fail to fire event io:xdrReady if the page is reloaded. A timestamp querystring is added to io.swf, in the XDR example, to correct this condition.
• Multiple HTML Submit buttons, in an HTML form, are not supported, at this time.
• File upload transactions, using io-upload-iframe.js, support string response data. XML is not supported, at this time.

Support & Community