Marimba's Castanet is a system for distributing, installing, and updating software and content over intranets and the Internet. Castanet's unit of distribution is called a channel; a channel can be a Java program or a Website. Channel developers create a channel's files with conventional programming or Website development tools. They use the Castanet Publisher to copy a channel's files to a Castanet Transmitter. Anyone can use a free Castanet Tuner to subscribe to a published channel. Subscribing downloads and installs a channel, which can then be run or displayed from the user's disk. Each channel includes a developer-provided schedule which the Tuner uses to automatically keep the channel current, downloading new and modified files as they are republished to the channel's Transmitter.
At first glance, Castanet might seem similar to downloading with FTP or a Web browser. In fact, Castanet goes far beyond FTP and browsers:
There are presently four kinds of Castanet channels:
Users subscribe to channels with a Castanet Tuner. They can launch subscribed channels either from the Tuner or from a mechanism provided by their desktop, such as choosing a channel from a menu or double-clicking on an icon representing the channel.
Each subscribed channel has an automatic update frequency that is specified by its developer (users can also direct the Tuner to check for updates). That frequency can be as high as every few minutes or as low as monthly. When it's time to check for updates to a channel, the Tuner contacts the channel's Transmitter, downloads and installs the updates, if any. Applet and application channels can be written to absorb updates while they are running, and channel developers can specify that a channel is to be launched automatically when the Tuner receives an update for it.
An HTML channel is a Website: a collection of Web pages and media files rooted in a common directory, with a designated first page that may link to other pages. The Castanet Tuner launches subscribed HTML channels by passing them to Web browsers. An HTML channel can contain links to pages outside itself, which will work if the network is available. Internal links work whether the computer is connected to the network or not.
A developer can designate an HTML channel as incremental. Whereas an ordinary HTML channel is downloaded completely when a user subscribes to it, an incremental HTML channel is downloaded page-by-page in response to user clicks. In this way, the just-subscribed channel is viewable almost immediately. After several minutes, the Tuner automatically transfers the remainder of an incremental HTML channel, or the user can direct to Tuner to complete the download immediately.
HTML channel developers can "instrument" their pages to log image displays and link clicks, which might represent advertising impressions and click-throughs, for example. Logging continues whether the user is connected to the network or not. The Tuner sends a channel's log to the channel's Transmitter its next update request; the log can be read by a Transmitter plugin written by the channel developer.
Presentation, applet, and application channels can all be considered executable channels. All executable channels can run on any Java platform, and all of them are subject to the Java applet security model, which provides the best protection for downloadable software. However, the applet security model is relaxed for channels in one important way: Each channel can read or write one directory on the local file system; the Tuner ensures that a channel can access only its designated directory.
Because channels can be updated automatically and efficiently, they can be much more dynamic than traditional application software, which is typically updated once a year or so. Channels are an excellent vehicle for distributing information that changes weekly, daily, hourly, or even more often. Examples include teaching channels that receive a new lesson every day, news channels that update sports scores every 15 minutes, and story channels whose casts and locales grow with time. Developers of more traditional application-style channels can distribute code improvements and bug fixes frequently confident that they'll be transmitted and installed correctly without user effort.
Developers of executable channels can direct the Tuner to send feedback data to the channel's Transmitter when the Tuner asks the Transmitter for updates to the channel. Anything the channel can record while it's running can be returned as feedback data: the users preferred language, counts of features used, and counts of errors made are a few examples. A developer-supplied channel component called a Transmitter plugin can log the feedback data or use it to customize the update data that the Transmitter returns to the Tuner. Although feedback data is a flexible and potentially powerful way to customize channels, users who object to the feature can disable it in their Tuners.
A channel can be more than software or a Website that's transmitted to a user's computer. An optional channel component called a plugin can reside with a Transmitter. Each channel served by a Transmitter can have its own plugin which serves all copies of the channel that have been downloaded from that Transmitter. Plugins can be written by developers or purchased from third parties.
A plugin processes feedback data created by instances of its channel. A Transmitter invokes a channel's plugin when a Tuner requests an update for the channel. The plugin can do anything with the feedback data. For example, the plugin may record the data for offline processing, or use it to perform a database lookup, or use it to select files to be returned to the requesting Tuner. By selecting files for transmission to the Tuner, a plugin can customize or personalize a channel instance. For example, a plugin may return French files for French users and German files for German users; it may increase the difficulty of a game channel based on the user's previous score; it may send advertisements related to those the channel user has clicked on; or it may send help on features the user has employed incorrectly. There's no limit to how feedback data can be employed by plugins. Note that although feedback data identifies the Tuner that sent it, it doesn't disclose the identity of the Tuner's user.
The Castanet Tuner is the receiver component of the Castanet distribution system. Marimba provides a Tuner that's a small Java application, and Netscape has integrated a Tuner into their Netcaster product. However it's packaged, a Tuner does three main things:
Each channel includes an update schedule provided by its developer. When it's time to update a channel, or the user directs the Tuner to do so, the Tuner connects to the channel's Transmitter. (If the network is not available, the Tuner postpones the update.) The Tuner and Transmitter compare the files constituting the channel. If the Transmitter has a newer version of a channel file, or a new file, it sends the file to the Tuner. Thus, channel updates are differential: only files that have changed since the channel was last updated are transmitted to the Tuner. To further conserve network bandwidth, small updates to large files are sent as editing commands which the Tuner executes. If a running channel's developer has indicated that the channel can be updated on the fly, the Tuner installs the new files immediately; otherwise it waits until the channel stops. Channel updates are performed atomically, like database transactions, so that a channel always has a consistent set of files, even if the power fails during an update. To conserve disk space, Tuners automatically garbage collect obsolete files, and keep only one copy of files that are shared among channels.
Tuners are themselves channels, and automatically update themselves once a week.
Castanet Transmitters serve channel files in response to Tuner requests, roughly as HTTP servers serve Web pages to Web browsers. Unlike HTTP servers, Transmitters send a Tuner only the files that are out of date on the Tuner's machine, and they send all of the files in a single network connection. Transmitters are, accordingly, more efficient than HTTP servers.
Each primary Transmitter maintains a list of the channels it serves; both Tuners and Web browsers can obtain the list, and users can subscribe to a channel on the list from either a Tuner or a Web browser.
For a given channel it serves, a Transmitter may play the role of primary Transmitter or repeating Transmitter. Repeating Transmitters can be used to distribute the load of transmitting a channel among multiple Transmitters which may or may not be geographically dispersed; repeating Transmitters also provide a measure of fault tolerance. The channel developer designates a Transmitter's role when he or she creates the channel. When the developer directs the Publisher to publish the channel, the Publisher updates the primary Transmitter and all Transmitters designated by the developer as repeaters.
A primary Transmitter maintains a list of the channels it serves; both Tuners and Web browsers can obtain the list, and users can subscribe to a channel on the list from either a Tuner or a Web browser. When a primary Transmitter receives a subscribe request from a Tuner or a Web browser, it assigns the requesting Tuner to itself or to one of the Transmitters that has been designated as a repeater for the channel. The primary Transmitter makes the assignment based on the strategy chosen by the channel developer. If a Tuner is unable to contact the repeating Transmitter to which it has been assigned, it returns to the primary Transmitter for a new assignment.
There are two repeater assignment strategies, round-robin and geographic. The round-robin strategy distributes subscriptions evenly among Transmitters, where "Transmitters" includes the primary and the repeating Transmitters. The geographic strategy assigns each subscription to the nearest Transmitter, whether it is a repeating Transmitter or the primary Transmitter. "Nearest" means the Transmitter whose time zone is nearest to that of the requesting Tuner.
Developers use conventional programming and Web page development tools to create the files that constitute a channel. A channel's files are subordinate to a single directory called the base directory; any directory can be a base directory. To create a channel, a developer uses the Castanet Publisher. Creating a channel with the Publisher primarily means adding a few files to the base directory. The most important file describes the channel's properties: its name, its type (HTML, application, etc.), its update frequency, how the Tuner should install updates, its primary and repeating Transmitters, and so on. The developer enters the properties in the Publisher's tabbed pages.
The Publisher is also used to publish a channel, which means to copy its files to its primary Transmitter and repeating Transmitters, if any. The Publisher transfers the files atomically, so that any network or computer problems do not result in a malformed channel on a Transmitter. Channels can be published interactively with the Publisher's graphical user interface, or programmatically with a script that invokes the Publisher from a command.
To revise a channel a developer modifies the relevant files in the channel's base directory and then publishes the channel again. The Publisher differentially copies the channel's files to the channel's Transmitters; that is, only new and updated files are transferred. Transmitters accept published channels on the fly. If a Transmitter receives a new version of a channel at the moment when it is transmitting the old version, it continues to serve the old version to Tuners that are already connected, and serves the new version to new Tuner connections. Transmitters automatically garbage collect obsolete channel files.
A Transmitter runs on a dedicated network port. At sites which also run HTTP (Web) servers behind firewalls, administration would be simpler if the Transmitter shared the same host and port as the HTTP server. A Castanet Gateway makes a Transmitter appear to run on the same host and port as a Netscape or Microsoft HTTP servers. A Gateway is an HTTP server plugin that forwards Tuner requests to a Transmitter running on a different host and/or port. In addition to making a Transmitter work with a firewalls that is configured for an HTTP server, a Gateway provides a measure of flexibility. A Transmitter can be moved (to a faster machine, for example), without disrupting Tuners that have subscribed to its channels; only the Gateway configuration has to be updated to forward Tuner requests to the new host.
A Castanet Proxy provides a channel file cache for a collection of Tuners, typically those on a local area network. Like an HTTP proxy, a Castanet Proxy conserves network bandwidth and improves responsiveness. Suppose, for example, that 100 Tuners on a department network subscribe to the same channel, and that one file in the channel is updated. The first Tuner request for an update will pass through the Proxy to the Transmitter; the Transmitter will return the new file to the Proxy which will both pass it to the requesting Tuner and add the file to its cache. Subsequent update requests will be satisfied by the Proxy without requiring the Transmitter to send the file again. Note that Proxies send Tuner feedback data to Transmitters for the benefit of channel plugins, and that plugins can customize channels whether a Proxy is present or not.