Patent Publication Number: US-7899785-B2

Title: Reconfiguring propagation streams in distributed information sharing

Description:
RELATED APPLICATIONS 
     This application is related to U.S. patent application Ser. No. 11/831,810, entitled “C ONFIGURING OR  R ECONFIGURING A  M ULTI -M ASTER  I NFORMATION SHARING  E NVIRONMENT ”, by inventors Y UAN ET AL ., filed on the same date as this application, the content of which is incorporated herein in its entirety, for all purposes; and 
     This application is related to U.S. patent application Ser. No. 11/247,973 entitled “R ECOVERABLE  E XECUTION ”, by inventors L AKSHMINATH ET AL ., filed on Oct. 10, 2005, the content of which is incorporated herein in its entirety, for all purposes; and 
     This application is related to U.S. Pat. No. 7,039,669, entitled “T ECHNIQUES FOR  A DDING A  M ASTER IN A  D ISTRIBUTED  D ATABASE WITHOUT  S USPENDING  D ATABASE  O PERATIONS AT  E XTANT  M ASTER  S ITES , by Wong et al., the content of which is incorporated herein in its entirety, for all purposes. 
     FIELD OF THE INVENTION 
     The present invention relates to information sharing systems. In particular, embodiments of the present invention relate to replicating database objects in a group of nodes. 
     BACKGROUND OF THE INVENTION 
     Replication is the process of sharing database objects and changes to those objects among multiple databases. As examples, the changes may be data manipulation changes (“DML changes”) or data definition changes (“DDL changes”) made by a database server. A typical log-based replication system involves at least two databases—a source database and a destination database, and has at least three components—a capture process to read changes from log files at a source database, a propagation process to send changes to a destination database, and an apply process to consume the changes at the destination database. 
     The term “capture” or “capture events” is used herein to refer to selecting events (e.g., changes) and adding messages to a staging area for subsequent processing. A capture process scans a redo log for DML or DDL changes and stages them into a queue for subsequent propagation to other database servers. The queued messages are captured and propagated to other database servers according to rules provided by the user. 
     The phrase “propagate a message” is used herein to refer to the activity of distributing messages generated by a capture process to other nodes for subsequent processing. The other node may be another database server, but is some cases could be the same database server. Message propagation may entail distributing messages from a staging area for one node to another staging area for subsequent processing at another node. A propagation process propagates messages. Propagating an event refers to propagating a message about the event. 
       FIG. 1  is a block diagram depicting an example replication environment used to propagate database changes among a network of database servers. Referring to  FIG. 1 , it shows messaging system  101 . Messaging system  101  includes three nodes, database server New York, database server Pittsburgh, and database server Chicago. Database server New York has a table sales. DML and DDL changes (e.g., updates, deletes, and inserts) made by database server New York are propagated via messaging system  101  to database servers Pittsburgh and Chicago so that changes may be reflected in their respective tables sales (not shown). 
     Database servers Pittsburgh and Chicago do not receive all DDL and DML changes made to table sales in database server New York. The particular changes propagated to database servers Pittsburgh and Chicago depend on the value of a column city (not shown). Changes to rows where the value of city equals ‘Pittsburgh’ are propagated to database server Pittsburgh; changes to rows where the value of city equals ‘Chicago’ are propagated to database server Chicago. 
     A capture process  103  captures changes to table sales at database server New York and, for each change, adds a message to message queue  105 . Capture process  103  captures the changes by scanning a redo log (not shown) maintained by database server New York. A redo log contains records that specify changes to rows in tables maintained by database server New York. Capture process  103  scans the redo log for records specifying changes to rows in table sales, adding a message to message queue  105  for changes to a particular row. 
     Propagate process  107  propagates messages queued in message queue  105  to database server Pittsburgh and propagate process  113  propagates messages queued in message queue  105  to database server Chicago. Messages reflecting changes to a row having city value equal to ‘Pittsburgh’ are propagated to database server Pittsburgh. Messages reflecting changes to a row having a city value equal to ‘Chicago’ are propagated to database server Chicago. 
     Apply processes  155  and  156  apply the propagated changes in the servers in Pittsburgh and Chicago. The term apply process refers to a process for reading messages in a staging area, such as a queue message queue  223 , and causing the database server to take some action to reflect the event described by a message. For example, a message in message queue  223  that reflects a DML change made to a table in database server New York is applied to database server Chicago by making a corresponding change to a corresponding table in database server New York. Applying an event or change refers to applying a message about the event. Processes that capture, propagate, or apply events are referred to herein as message flow processes or flow processes. 
     Rules are used to decide what changes to capture and what messages to propagate. To determine what changes to what particular rows are captured, capture process  103  executes capture rules  109 . The condition for a rule in capture rules  109  is expressed as a SQL expression that can reference a variable specifying the “source table” affected by a change or a column of the table. The following predicate expression is used in a rule to capture changes to source table sales.
 
source_table=“sales”
 
     Propagate processes  107  and  113  evaluate propagate rules  111  and  115 , respectively, to determine how to propagate a message from message queue  105 . A rule condition that specifies to propagate to database server Pittsburgh messages reflecting changes to a row with city value equal to ‘Pittsburgh’ may be expressed using the following predicate expression.
 
source_table=“sales” AND
 
city=“Pittsburgh”
 
     The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated, it should not be assumed that any of the approaches described in this section qualify as prior art merely by virtue of their inclusion in this section. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The present invention is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings and in which like reference numerals refer to similar elements and in which: 
         FIG. 1  is a block diagram depicting an example replication environment used to propagate database changes among a network of database servers; 
         FIG. 2A  depicts an example replication topology having several co-master database servers and several slave database servers, in accordance with an embodiment of the present invention; 
         FIG. 2B  shows a new node added to the example replication topology of  FIG. 2A , in accordance with an embodiment of the present invention; 
         FIG. 2C  shows the new node after it has been promoted to a master, in accordance with an embodiment of the present invention; 
         FIG. 3  is a flowchart illustrating a process of adding a new node as a master DBS, in accordance with an embodiment of the present invention; 
         FIG. 4A  shows a bi-directional replication environment having two nodes, each of which is a co-master, in accordance with an embodiment of the present invention; 
         FIG. 4B  shows a configuration in which a slave DBS is added to the configuration of  FIG. 4A , in accordance with an embodiment of the present invention 
         FIG. 5  is a flowchart illustrating a process of adding a new node as a slave, in accordance with an embodiment of the present invention; 
         FIG. 6  shows the configuration of  FIG. 4B  after promoting the slave DBS to a master, in accordance with an embodiment; 
         FIG. 7  is a flowchart of a process for promoting a slave to a master, in accordance with an embodiment; 
         FIG. 8A  shows a configuration having a single propagation stream, in accordance with an embodiment; 
         FIG. 8B  shows the original propagation of  FIG. 8A  split into two propagations, in accordance with an embodiment; 
         FIG. 9  illustrates a process for determining which changes to objects at the source node should be captured after merging streams, in accordance with an embodiment of the present invention; 
         FIG. 10  shows two data streams in a one-directional replication environment, in accordance with an embodiment of the present invention; 
         FIG. 11  describes a process for adding a new object to a replication environment by merging the new stream with an original stream, in accordance with an embodiment of the present invention; 
         FIG. 12  is a block diagram of a computer system on which embodiments of the invention may be implemented; and 
         FIG. 13  shows an overview of a process for splitting and merging propagation streams, in accordance with an embodiment of the present invention. 
     
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     A method and system are described for sharing electronic information. In the following description, for the purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be apparent, however, that the present invention may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form in order to avoid unnecessarily obscuring the present invention. 
     Overview 
     Techniques for configuring an n-way multi-master information sharing topology are described herein. The n-way multi-master topology can also be referred to as a peer-to-peer information sharing topology, in which co-master nodes replicate changes that are sent from every other co-master node. The information sharing topology can also have non-master nodes that only replicate changes sent from one of the master nodes. Examples are provided herein in which the nodes are database servers (DBSs); however, the nodes are not limited to being DBSs. 
     Application Program Interfaces (APIs) in accordance with embodiments of the present invention support configuring master DBSs and non-master DBSs in an information sharing topology. The APIs can configure an arbitrary topology. In one embodiment, a database administrator can invoke an API from a source DBS to set up an n-way multi-master configuration with an arbitrary number of destination DBSs. APIs in accordance with embodiments of the present invention can be used to promote a non-master DBS to a master DBS. APIs in accordance with embodiments of the present invention can be used to downgrade a master DBS to a non-master DBS. 
     Adding a new node (e.g., DBS) to the information sharing topology is implemented as follows, in an embodiment. Initially, the new node is added as a slave of a particular one of the co-masters. A capture process is created on the particular co-master to send changes to the objects to the slave. Furthermore, the objects to replicate are instantiated on the new node by propagating data from the particular co-master to the new node. Meanwhile, the co-masters continue to propagate changes to each other. Eventually, the new node may be made a co-master. 
     Promoting a slave node to a master node is implemented as follows, in an embodiment. Initially, the node is designated as a slave of a particular one of the co-masters. As a slave, the node receives changes from only the particular master. Meanwhile, the co-masters propagate changes to each other. To promote the slave to a master, changes to objects stored at the slave are propagated to each of the co-masters. Furthermore, changes at each of the masters are propagated to the promoted node. 
     APIs in accordance with an embodiment can enhance performance of the configuration. For example, a particular DBS configured as a new master DBS might significantly lag behind the co-master DBSs with respect to applying changes. Were no steps to be taken to alleviate the problem, each co-master DBS could be forced to re-mine a large number of data from log files, thus impacting performance. However, the APIs can be used to downgrade a particular DBS from a master DBS to a non-master DBS such that it does not impact the other master DBSs. Eventually, the particular DBS can be promoted back to a master DBS. Furthermore, an arbitrary number of DBSs can be added into or removed from an n-way multi-master information sharing topology. 
     Techniques for splitting and merging database object information sharing streams are described herein. Streams are also referred to herein as “propagations”. Splitting and merging information sharing streams can be used to improve performance in an information sharing environment when a failed or slow DBS or network impacts the performance. In one embodiment, an auto split process monitors the progress of applying changes at each node and detects the presence of a failed or a slow node. Once the failed or slow node is identified, the auto split process splits the propagation such that the offending node is sent by a separate propagation. Furthermore, an auto merge process can be started to monitor the newly created separate propagation. At a later point, the new propagation can be merged back into the original stream. For example, if the offending node catches up with other nodes, the auto merge process merges the newly created propagation back to the original propagation. 
     In one embodiment, a user can invoke an API that automatically splits a propagation when appropriate. For example, the propagation is split when one of the DBSs applying changes is slow. Furthermore, the API automatically merges the split back together when appropriate. 
     In another embodiment, an API automatically splits the streams when appropriate. However, the split streams are not automatically merged. The split streams can be merged by the user invoking a PL/SQL procedure of the API, if desired. 
     In still another embodiment, an API automatically merges two streams regardless of whether or not the two were split at one point. As an example, the user might have invoked a procedure to split a stream. Then, the user invokes the API, which automatically merges two streams when a condition is met. 
     In one embodiment, shared objects can be added into an information sharing environment. For example, tables or schemas can be added to an information sharing environment. In accordance with one embodiment, adding an object (“new object”) includes propagating, from a first node to a second node in the information sharing topology, a first stream that describes changes to information sharing objects at the first node. A second stream, which describes changes to the new object, is also propagated from the first node to the second node. Then, the propagation of the first stream and the second stream are stopped. Based on changes to the information sharing objects and changes to the new object that were applied at the second node at the point at which the first and second streams were stopped, a point at which to re-start the first stream is determined. Then, the first stream is re-configured to propagate changes at the first node to the new object in addition to changes to the information sharing objects. Next, the first stream is re-started to propagate, from the first node to the second node, changes to the new object and the information sharing objects. 
     Example N-Way Co-Master Information Sharing Topology 
       FIG. 2A  depicts an information sharing topology  200  having several co-master DBSs  202   a - 202   c  and several slave DBSs  204   a - 204   b , in accordance with an embodiment of the present invention. Each master DBS  202  propagates changes to every co-master DBS  202 , which replicate those changes on the databases that they control. Each slave DBS  204  exchanges changes with one particular master DBS  202 , in this embodiment. It is not required that a slave DBS  204  be allowed to make changes to information sharing objects. As previously discussed, for purposes of illustration DBSs are used as examples of nodes. 
     The particular master DBS of the slave DBS propagates the changes from all of the co-masters to its slave DBS  204  and from its slave DBS  204  to the other masters  202 . For example, master DBS  202   a  propagates its own changes, as well as changes from the co-master DBSs  202   b - 202   c  to slave DBS  204   a . Slave DBS  204   a  propagates its changes only to master DBS  202   a , which propagates those changes on to the co-master DBSs  202   b  and  202   c.    
     A master DBS  202  may apply the changes from its own slave DBS  204 , then capture those changes, and propagate those captured changes. Propagating these captured changes is referred to as “apply forwarding”. As an alternative, a master DBS  202  may use “queue forwarding.” In queue forwarding, the changes from the slave DBS  204  that are applied at the master DBS  202  are not captured at master DBS  202 . Instead, these changes are forwarded from the queue at the master DBS  202  to all other master DBSs  202 . 
     Overview of Information Sharing Concepts 
     1) General Overview 
     A log capture process is an example of a capture process. However, capture processes are not limited to log capture processes. According to one embodiment, a log capture process is a process configured to read information stored in the log files of a DBS, and to store information into one or more staging areas based on the information in the log files. Such log files may include, for example, the redo log files that are generated by the database system to record changes that are being made by the database system. 
     With respect to capturing changes, users can configure a background log capture process to capture changes made to tables, schemas, or the entire database. According to one embodiment, a log capture process captures changes from the redo log and formats each captured change into a “logical change record” (LCR). The database where changes are generated in the redo log is called the source database. 
     With respect to placing events into a queue, at least two types of events may be staged in a queue in the information sharing topology  200 : LCRs and user messages. A capture process enqueues events into a queue that users specify. The queue can then share the events within the same database or with other databases. Users can also enqueue user events explicitly with a user application. These explicitly enqueued events can be LCRs or user messages. 
     With respect to propagating events from one queue to another, the queues may be in the same database or in different databases. With respect to dequeueing events, a background apply process can dequeue events. Users can also dequeue events explicitly with a user application. 
     With respect to applying events at a database, users can configure an apply process to apply all of the events in a queue or only the events that users specify. Users can also configure an apply process to call user-created subprograms (e.g. subprograms written in the PL/SQL language) to process events. The database where events are applied and other types of events are processed is called the destination database. In some configurations, the source database and the destination database may be the same. 
     2) Apply Process Overview 
     According to one embodiment, an apply process is a background process, running within a DBS, that dequeues events from a queue and either applies each event directly to a database object or passes the event as a parameter to a user-defined procedure called an apply handler. These apply handlers can include message handlers, DML handlers, DDL handlers, and procedure handlers. 
     According to one embodiment, an apply process is designed to be aware of transaction boundaries. For example, an apply process is aware of which changes, represented in the LCRs that the apply process is consuming, were initially made as part of the same transaction. The apply process assembles the changes into transactions, and applies the changes in a manner that takes into account the dependencies between the transactions. According to one embodiment, the apply process applies the changes in parallel, to the extent permitted by the dependencies between the transactions. 
     As mentioned above, LCRs are merely one example of the type of shared information that may be handled by an apply process. Apply processes may be configured to “apply” any form of shared information, including explicitly enqueued user messages and automatically captured data that is not organized as an LCR. 
     3) Oldest SCN 
     According to one embodiment, when the changes that are being applied are part of transactions, an acknowledge (ACK) message sent upstream by the apply process includes an OLDEST SCN (system change number) value. The OLDEST SCN is the oldest change SCN of LCRs of all uncommitted transactions. According to one embodiment, the OLDEST SCN value is persistently stored by the apply process, and periodically communicated upstream using ACK messages. 
     The oldest change SCN for a transaction will typically be the SCN associated with the first change made by the transaction. To maintain the OLDEST SCN up-to-date, the apply process may “raise” the OLDEST SCN when the transaction associated with the current OLDEST SCN is fully applied. For example, consider the follow three transactions: 
     TX 1  with changes at SCN 12, 13, 17, 20 
     TX 2  with changes at SCN 11, 14, 15, 18, 19 and 23 
     TX 3  with changes at SCN 16, 21, 22, 24 and 25. 
     If TX 1 , TX 2  and TX 3  are the only uncommitted transactions for which the apply process received changes, then the OLDEST SCN will be 11 (the oldest change SCN from any of the uncommitted transactions). Assume that the apply process first finishes applying TX 1 . At that point, the LAST COMMITTED SCN would be changed to 20, but the OLDEST SCN does not change, because TX 1  was not the transaction associated with the OLDEST SCN. 
     If the apply process then finishes applying TX 2 , then the OLDEST SCN would be updated to 16, since the only uncommitted transaction would be TX 3 , and the oldest change SCN of TX 3  is 16. At this point, the LAST COMMITTED SCN would also be changed to 23. 
     By maintaining the OLDEST SCN in this manner, all changes associated with change SCNs below the OLDEST SCN are guaranteed to have been applied. Thus, in the case of a failure, it is safe for the apply process to read the persistently stored OLDEST SCN, and to request the upstream components to resend the change information starting at the OLDEST SCN. 
     4) Low Watermark SCN 
     According to one embodiment, a LOW WATERMARK SCN is the SCN such that all transactions that have a commit SCN lower than or equal to the LOW WATERMARK SCN are guaranteed to have been applied. It is possible for the LOW WATERMARK SCN to be less than the commit SCN of the most recently applied transaction. 
     To maintain the LOW WATERMARK SCN up-to-date, the apply process “raises” the LOW WATERMARK SCN when (1) the apply process finishes applying a transaction that has a commit SCN that is above the current LOW WATERMARK SCN, and (2) no unapplied transaction has a commit SCN lower than or at the commit SCN of the transaction that has just been applied. 
     For example, assume that transactions TX 1 , TX 2  and TX 3  have commit SCNs of 17, 20 and 25, respectively. Assume that (1) TX 1  has been applied, (2) the current LOW WATERMARK SCN is 17, and (3) the apply process applies TX 3  before TX 2 . When TX 3  is fully applied, the LOW WATERMARK SCN is not updated because an unapplied transaction (TX 2 ) has a lower commit SCN than the commit SCN of TX 3 . After TX 2  is applied, the LOW WATERMARK SCN is updated to 25, since all transactions with commit SCNs at or below 25 have been applied. 
     5) Above-Mark Applied Transactions 
     The already-applied transactions with commit SCNs above the LOW WATERMARK are referred to herein as the ABOVE-MARK APPLIED transactions. In the example given above, when TX 3  was fully applied before TX 2 , TX 3  became an ABOVE-MARK APPLIED transaction. According to one embodiment, in addition to the LOW WATERMARK SCN, the apply process persistently stores information about the ABOVE-MARK APPLIED transactions. According to one embodiment, the information about the ABOVE-MARK APPLIED transactions is maintained in a hash table in volatile memory, and the hash table is backed up on persistent storage. 
     6) Positive Rule Sets and Negative Rule Sets 
     According to an embodiment of the present invention, a message flow process processes rule sets as positive rule sets or negative rule sets when using rules to determine how to process an LCR. A message flow process may use a positive rule set, negative rule set, or a combination thereof, to determine whether or not to keep or discard an LCR. The meaning of the terms “keep an LCR” or “discard an LCR” depends on whether it is being used within the context of a capture, propagation, or apply process. For a capture process, an LCR is kept by adding it to a message queue; for a propagation process, the LCR is kept by propagating it; for an apply process, the LCR is kept by applying it. An LCR that is not kept is referred to as being discarded. 
     For positive rule sets, if the rule set evaluates to TRUE, then the flow process keeps the LCR. Thus, if any rule in a positive rule set is TRUE, then the rule set is TRUE, and the LCR is kept. 
     For negative rule sets, if the rule set evaluates to FALSE, the LCR is kept. Thus, if all rules in the rule set are FALSE, then the rule set is FALSE, and the LCR is kept. If any rule in the rule set is TRUE, then the rule set result is TRUE, and the LCR is discarded. 
     Overview of Process of Adding a Node as a Master DBS 
       FIG. 3  is a flowchart illustrating a process  300  of adding a new node as a master DBS  202 , in accordance with an embodiment of the present invention. In general, process  300  includes initially adding a new DBS as a slave DBS  204  and then promoting the slave to a master DBS  204 . Step  302  describes the initial configuration in which each of the co-master DBSs  202  exchange changes to objects with each other. For example, each co-master DBS  202  captures changes that occur to the information sharing objects stored at its database and propagates those changes to each other co-master DBS  202 , which apply those changes. 
     In step  304 , a new node is established as slave DBS  204  to a particular master DBS  202 . When the new node is acting as a slave DBS  204 , the particular master DBS  202  forwards changes from all of the co-master DBS  202  to the new node. Moreover, the particular master DBS  202  captures changes that occur to the objects at the particular master DBS  202 , and propagates the captured changes to the new node.  FIG. 2B  shows a new node  204   c  added to the example information sharing topology of  FIG. 2A , in accordance with an embodiment of the present invention. In  FIG. 2B , the new node  204   c  is a slave to master DBS  202   c.    
     In step  306 , the new node is promoted to a master DBS  202 . When acting as a master DBS  202 , the new node captures changes to objects stored at its database and propagates those changes on to each co-master DBS  202 . Furthermore, each co-master DBS  202  propagates its changes to the new node.  FIG. 2C  shows the new node after it has been promoted to a master DBS  202   d , in accordance with an embodiment of the present invention. 
     Example of Adding a Node as a Slave 
       FIGS. 4A and 4B  illustrate further details of adding a new node as a slave, in accordance with an embodiment.  FIG. 4A  shows a bi-directional information sharing environment having two nodes, each of which is a co-master. For simplicity only two co-masters and no slaves are depicted; however, there could be many co-master DBS  202 , as well as slave DBS  204 . At DBS 1 , a capture process (CAP@DBS 1 ) captures changes at DBS 1  and a propagation (PROP_DBS 1 _TO_DBS 2 ) sends the changes to DBS 2 . At DBS 2 , the apply process (APP_FOR_DBS 1 @DBS 2 ) applies the changes that occurred at DBS 1 . At DBS 2 , a capture process (CAP@DBS 2 ) captures changes to DBS 2 , which propagation process (PROP_DBS 2 _TO_DBS 1 ) sends to DBS 1 . At DBS 1 , apply process (APP_FOR_DBS 2 @DBS 1 ) applies those changes. 
     To prevent changes to DBS 1  cycling back to DBS 1 , all changes originating from DBS 1  and applied by APP_FOR_DBS 1 @DBS 2  are tagged with the globally unique object identifier of APP_FOR_DBS 1 @DBS 2 . A rule is added to a negative rule set of PROP_DBS 2 _TO_DBS 1  to filter out all changes tagged with the globally unique object identifier of APP_FOR_DBS 1 @DBS 2 . Tags and rules can be set up similarly to prevent changes originating at DBS 2  cycling back to DBS 2 . 
       FIG. 4B  shows a configuration in which DBS 3  is added as a slave DBS  204  of master DBS 1 . The master to the slave will be referred to herein as the “particular master” to distinguish it from the other masters. The particular master (DBS 1 ) forwards all the changes made at other co-master databases (DBS 2 ) to a slave database (DBS 3 ). In one embodiment, a slave DBS  204  is not allowed to make any changes to objects in the information sharing topology. In another embodiment, a slave DBS  204  is allowed to make changes. If a slave DBS  204  is allowed to make changes, the slave propagates those changes to only its particular master DBS  202 , in an embodiment. 
     At DBS 1 , a new capture process (cloned CAP in  FIG. 4B ) is created to capture changes to be sent to DBS 3 . This new capture process is created by cloning CAP@DBS 1 , in one embodiment. However, it is not a requirement that this new capture process be cloned from another capture process. Prior to sending any changes, whatever information sharing objects are stored at DBS 1  are exported from DBS 1  and imported by DBS 3 . Because the data set associated with the information sharing objects may be large, the export/import may take a long time. However, because CAP@DBS 1  is not used to send changes to DBS 3 , DBS 3  does not negatively impact CAP@DBS 1 . That is, even if DBS 3  is slow at applying changes, the other DBS can continue to apply changes from CAP@DBS 1 . 
     Furthermore, a capture process (CAP@DBS 3 ) is created at DBS 3  to capture changes from DBS 3  and send them to the particular master DBS 1 . An apply process (APP_FOR_DBS 3 @DBS 1 ) is created at DBS 1  to apply changes from DBS 3 . A propagation (PROP_DBS 3 _TO_DBS 1 ) is created to propagate changes from DBS 3  to DBS 1 . Negative rules may be added to PROP_DBS 3 _TO_DBS 1  and PROP_DBS 1 _to_DBS 3  to prevent changes from cycling. 
       FIG. 5  is a flowchart illustrating a process  500  of adding a new node as a slave to a particular master node, in accordance with an embodiment of the present invention.  FIGS. 4A and 4B  will be used to help describe process  500 . In step  503 , a capture process is created at the particular master node. For example, CLONED_CAP is created to allow DBS 1  to capture changes to information sharing objects at DBS 1 . In one embodiment, creating the capture process includes creating a capture queue. In one embodiment, creating the capture process includes adding positive rules from the existing capture (CAP@DBS 1 ) to a rule set for the new capture process. 
     In step  505 , the current SCN of the particular master DBS is queried. In step  507 , export of the information sharing objects from the particular master and import of the objects to the new node is initiated. The export is performed at the current SCN of the particular master DBS, which was queried in step  505 . 
     In step  510 , an apply process, which is for changes from the particular master DBS, is created at the new node. For example, APP_FOR_DBS 1 @DBS 3  is created to allow DBS 3  to apply changes from DBS 1 . Further, the apply process is informed as to which changes it should apply from its particular master. For example, the SCN of DBS 1  that was queried in step  504  is provided to the new node&#39;s apply process. Thus, the apply process will know which changes to apply. In one embodiment, creating the apply process includes creating an apply queue. In one embodiment, creating the apply process includes adding apply rules to a rule set. 
     In step  512 , a propagation process to send changes from the particular master DBS to the slave DBS is created. For example, PROP_DBS 1 _TO_DBS 3  is created. In step  514 , the newly created capture process at the particular master DBS, the apply process at the slave DBS and the propagation processes are started. 
     As previously discussed, the new node may or may not be allowed to make and propagate changes to information sharing objects. If the new node is allowed to make changes, a new capture process (e.g., CAP@DB 3 ) is created at the new DBS to capture changes at the new node. Furthermore, a new apply process (e.g., APP_FOR_DBS 3 @DBS 1 ) (along with apply rules) is created at the particular master DBS to apply changes from the new node. A new apply queue is also created at the particular master DBS, in an embodiment. Furthermore, a new propagation process (PROP_DBS 3 _TO_DBS 1 ) is created to forward the changes from the slave&#39;s capture process to the particular master&#39;s apply process. Furthermore, negative rules may be added to PROP_DBS 3 _TO_DBS 1  and PROP_DBS 1 _to_DBS 3  to prevent changes from cycling. 
     Example Process of Promoting a Slave to a Master 
     A slave DBS  204  is promoted to a master DBS  202  in accordance with an embodiment. In one embodiment, an API is provided to allow a user to select a node to promote to master.  FIG. 6  shows the configuration after promoting a slave to a master, in accordance with an embodiment.  FIG. 7  is a flowchart of a process  700  for promoting a slave to a master, in accordance with an embodiment. In step  702 , the particular master stops applying changes from co-masters and from the slave. For example, APP_FOR_DBS 2 @DBS 1  is stopped. 
     In step  703 , the apply process for the slave at the particular master DBS is stopped. For example, APP_FOR_DBS 3 @DBS 1  is stopped. Furthermore, the SCN at the particular master and the LWM of the apply process for the slave are queried. 
     In step  704 , information is collected that is pertinent to changes at the particular master DBS. For example, the current SCN of the particular master DBS is queried. The current SCN of the particular master DBS may be used as a stopping point for apply processes at the slave. Furthermore, the low watermark and oldest SCN of APP_FOR_DBS 2 @DBS 1  are queried. 
     If there are other apply processes at the particular master DBS, the low watermark and oldest SCN is queried for each apply process. For example, the low watermark and oldest SCN is queried for apply processes corresponding to every other co-master. The oldest SCN for an apply process is provided to the co-master that captured the changes being applied at the particular master, in an embodiment. The oldest SCN informs the co-master which changes should be captured when the capture process is restarted, in an embodiment. The low watermark is provided to the slave node, in an embodiment. The slave node uses the low watermark to determine which changes from the other co-masters should be applied once the slave node has been promoted to a master. 
     The slave DBS apply process (APP_FOR_DBS 1 @DBS 3 ) is allowed to run until the previously mentioned current SCN of the particular master DBS, at which point the slave&#39;s apply process is stopped, in step  706 . Furthermore, apply processes at co-masters are allowed to run until they reach the current SCN of the particular master DBS, in an embodiment. The LWM of an apply process at the point at which it is stopped is used as an instantiation SCN, in an embodiment. There should not be any applied transaction above the LWM. In other words, there should not be any above-mark applied transactions. If there are above-mark applied transactions, then the process  700  should be repeated. 
     In step  708 , apply processes are created at the slave node for each of the co-masters. For example, an apply process (APP_FOR_DBS 2 @DBS 3 ) is created at DBS 3  to apply changes from DBS 2 . Apply processes are also created for DBS 3  by other co-master DBS  202 . In one embodiment, an apply queue is created for each apply process. The apply tag for each new apply process is set to be the object identifier (OID) of the apply process, in an embodiment. 
     The new apply processes at the slave are also informed as to which changes from the co-masters are to be applied. For example, to apply changes from DBS 2 , an instantiation SCN of DBS 2  is set to be the low watermark of APP_FOR_DBS 2 @DBS 1 , in an embodiment. The instantiation SCN of DBS 2  provides the apply processes at DBS 3  with a logical point, such that changes that occurred at DBS 2  after the logical point should be applied at DBS 3 . For the apply processes for the co-masters at the slave node, the instantiation SCN is set to the low watermark for other apply processes at the particular master, which were collected in step  704 . Then, the new apply processes at the slave node are started. For example, APP_FOR_DBS 2 @DBS 3  is started. 
     In step  710 , propagations are created to and from the slave node. For example, a new propagation (PROP_DBS 1 _TO_DBS 3 ) is created from DBS 1  to DBS 3  to propagate changes captured by CAP@DBS 1 . In one embodiment, rules are added to a negative rule set of the propagation to prevent change cycling. The rules could be in the format of “tag=OID of apply process”, for every apply process at the database from which the propagation originates. The databases from which the propagation originates could include any of the masters as well as the new master. For the propagations from each of the co-master nodes to the slave node, a set of positive rules are added, in an embodiment. The positive rules are copied from the positive rule set from the propagation from a given co-master to the particular master, in one embodiment. 
     In step  714 , apply processes are created at all of the co-masters for applying changes from the slave node. For example, a apply processes (APP_FOR_DBS 3 @DBS 1  and APP_FOR_DBS 3 @DBS 2 ) are created to apply changes from DBS 3 . These new apply processes at the co-masters are also informed as to which changes from the slave node are to be applied. The information that is provided depends on whether or not the slave node (e.g., DB 3 ) is allowed to make changes. For example, the slave node may or may not be allowed to make user or local changes. 
     If the slave node is not allowed to make changes, then an instantiation SCN of DBS 3  is established as the current SCN of DBS 3 . The new apply processes at the co-masters use the instantiation SCN of DBS 3  to determine which changes from DBS 3  are to be applied. 
     However, if the slave node is allowed to make local changes, then the LWM from step  703  is used as the instantiation SCN of the slave node. Again, the new apply processes at the co-masters use this instantiation SCN of DBS 3  to determine which changes from the slave node are to be applied. Moreover, the oldest_scn that was queried in step  703  is used to restart the capture process at the slave node. 
     In step  716 , the capture and propagation processes that were used to send changes from the particular master to the slave are disabled. For example, referring to  FIG. 4B , the cloned CAP and the propagation from the cloned CAP to the slave node are disabled. However, APP_FOR_DBS 1 @DBS 3  does not need to be disabled. Rather, that apply process can continue to be used, based on changes from CAP@DBS 1 . 
     In step  718 , the newly created capture, apply, and propagation processes are enabled. 
     In one embodiment, a slave node is added to as a master database directly, without making it a slave and then promoting it to a master. The steps to do this is very similar to the processes  500  and  700  described in  FIG. 5  and  FIG. 7 , except that there is no need to create a new capture process at the source database. 
     Example Pseudocode of Promoting a Slave to a Master 
     The following describes pseudocode of promoting a slave node to a master node, in accordance with one embodiment. In the example pseudocode, the node that is being promoted from slave to master is referred to as the destination node. The “source node” is the master node to the destination node when the destination acts as a slave. In the example pseudocode, temp_propagation, temp_capture, temp_apply, source_temp_queue, and dest_temp_queue refer to the propagation, capture, apply, and queues that are established when first adding the destination node as a slave. For example, referring to  FIG. 4B , APP_FOR_DBS 1 @DBS 3  can serve as temp_apply and CLONED_CAP can serve as temp_capture. 
     Perform the following at the source node:
         a. Stop All apply processes for master nodes other than the source node (OtherMasters).   B. Query the low watermark and oldest_scn of all apply process.   c. Query the current SCN of the source (current_scn2). The current SCN is provided to the apply process at the destination that applies changes from the Source with the understanding that the apply processes are to stop at the current SCN.       

     Perform the following actions for each of the OtherMasters:
         d. Get the oldest SCN and low watermark of each apply process at the source node.   e. Create an apply queue at the destination node to receive changes from each OtherMaster. Create an apply process at the destination node for each OtherMaster and add positive rules to the apply process.   f. Create an apply queue at each OtherMaster node to receive changes from destination. Create a apply process at each OtherMaster for the destination and add positive rules to the apply process.   g. At destination node, set the instantiation SCN of the OtherMaster as low watermark.   h. Create a propagation to Destination. Add rules from the positive rule set of the propagation from this OtherMaster to Source to its positive rule set. Disable it.   i. Get apply_obj# for applies that apply changes from Source/OtherMasters/Destination, and add rule tag=apply_obj1∥apply_obj2∥ . . . to its negative rule set.   j. Restart capture at OtherMasters from oldestSCN.   k. Start the apply process that applies its change at Destination.       

     Perform the following at the Destination node:
         l. If no queue exists for the apply process that applies changes from Source, create an apply queue.   m. If no queue exists for the capture process, create a capture queue.   n. Create an apply process for the source node and add rules for the apply process.   o. Create propagation to all other databases and add propagation rules. Get apply_obj# (apply_obj1, aply_obj2 . . . ) for apply processes that apply changes from Source/OtherMasters, including temp_apply, and add rule tag=tag=apply_obj1∥apply_obj2∥ . . . to its negative rule set.   a. Create a capture process and add positive rules for capture process.   b. Get current SCN of Source, and let temp_apply stop at this SCN. Wait until apply_temp stops.   c. Get low watermark and oldest SCN of temp_apply.   d. Start the apply process at low watermark of temp_apply.   p. Start capture process.       

     Perform the following at the source node
         q. Create a propagation from Source to Destination. Add rules from positive rule set of temp_propagation to positive rule set of this new propagation.   r. Get apply_obj# for applies that apply changes from OtherMasters/Destination. Add negative rules, and disable this new propagation.   s. Restart capture at oldest scn of temp_apply.       

     Drop temp_propagation, temp_capture, temp_apply, source_temp_queue, and dest_temp_queue. 
     Enable all disabled processes. 
     Example of Downgrading a Master to a Slave 
     In an embodiment, a master is downgraded to a slave. Referring to  FIG. 6 , the following describes an example in which DBS 3  is downgraded from a master to a slave of DBS 1 . The current SCN of DBS 2  is obtained. Apply processes (APP_FOR_DBS 2 @DBS 3  and APP_FOR_DBS 2 @DBS 1 ) that apply changes from DBS 2  stop at this SCN. When they stop, these two apply processes should have no unapplied transactions with a commit SCN greater than the low watermark. If they do have any such transactions, then the current SCN of DBS 2  is again obtained, and the apply processes run until this current SCN. This step ensures that DBS 1  and DBS 3  have applied the same set of transactions from DBS 2 , and it is safe to let DBS 1  forward changes from DBS 2  to DBS 3  from this point. 
     The current SCN of DBS 3  is obtained, and the apply process (APP_FOR_DBS 3 @DBS 1  and APP_FOR_DBS 3 @DBS 2 ) that apply changes from DBS 3  stop at this SCN. When they stop, the two apply process should have no unapplied transactions with a commit SCN greater than the low watermark. If they do have any such transactions, then the current SCN of DBS 3  is again obtained, and the apply processes run until this current SCN. This step ensures that DBS 1  and DBS 2  have applied the same set of transactions from DBS 3 , and it is safe to let DBS 1  forward changes from DBS 3  to DBS 2  from this point. 
     The propagation from DBS 2  to DBS 3  (PROP_DBS 2 _TO_DBS 3 ) is dropped. Furthermore, the apply process at DBS 3  for the changes from DBS 2  (APP_FOR_DBS 2 @DBS 3 ) is dropped. Similarly, the propagation from DBS 3  to DBS 2  (PROP_DBS 3 _TO_DBS 2 ) and the apply process at DBS 2  for changes from DBS 3  (APP_FOR_DBS 3 @DBS 2 ) are dropped. 
     When all apply processes at DBS 1  stop, the current SCN of DBS 1  is queried. Apply processes (APP_FOR_DBS 1 @DBS 3  and APP_FOR_DBS 1 @DBS 2 ) that apply changes from DBS 1  are to stop at this SCN. This step ensures that changes from DBS 2  until this point are filtered by propagation from DBS 1  to DBS 3 , and changes from DBS 3  until this point are filtered by propagation from DBS 1  to DBS 2 . 
     Then wait until APP_FOR_DBS 1 @DBS 3  stops. The negative rules of PROP_DBS 1 _TO_DBS 3  are changed, so that changes tagged with the object identifier of APP_FOR_DBS 2 @DBS 1  will not be filtered by the propagation. PROP_DBS 1 _TO_DBS 3  will forward changes from DBS 2  to DBS 3 . 
     Then wait until APP_FOR_DBS 1 @DBS 2  stops. The negative rule of PROP_DBS 1 _TO_DBS 2  are changed, so that changes tagged with the object identifier of APP_FOR_DBS 3 @DBS 1  will not be filtered by the propagation. PROP_DBS 1 _TO_DBS 2  will forward changes from DBS 3  to DBS 2 . 
     CAP@DBS 2  is re-started from the oldest_scn of APP_FOR_DBS 2 @DBS 1 . CAP@DBS 3  is re-started from the oldest_scn of APP_FOR_DBS 3 @DBS 1 . CAP@DBS 1  is re-started from the oldest_scn of APP_FOR_DBS 1 @DBS 3 . All apply processes are then re-started. 
     General Process for Downgrading a Master to a Slave 
     The following section provides a general description for downgrading a master to a slave. In the general description, the slave is referred as Destination, and the master of the slave is referred to as Source. All other nodes in the n-way configuration are referred as OtherMaster. 
     For each of OtherMaster, get the current SCN, and let all apply process that apply changes from it stop at this SCN. Ensure for every apply process that there is no unapplied transactions with a commit SCN greater than the low watermark of the apply process. 
     For Destination, get the current SCN, and let all apply processes that apply changes from it stop at this SCN. Ensure for every apply process that there is no unapplied transactions with a commit SCN greater than the low watermark of the apply process. 
     At Destination, Drop all apply processes that apply changes from OtherMaster. Drop all propagation that sends changes to OtherMasters or get changes from Other Masters. For every OtherMaster, Drop the apply process that applies changes from Destination. 
     At Source, wait till all apply processes at Source stop. Get the current SCN of Source, and let all apply processes that apply changes from Source stop at this SCN. Ensure for every apply process that there is no unapplied transaction with a commit SCN greater than the low watermark of the apply process. 
     At Destination, wait till the apply process that apply changes from Source stops. Change the negative rule of the propagation that sends changes from Source to Destination, so that changes propagated from OtherMaster to Source will be forwarded to Destination. 
     For each OtherMaster:
         Wait until the apply process that apply changes from Source to this OtherMaster stops.   Change the negative rule of the propagation from Source to this OtherMaster, so that changes from Destination will forwarded to this OtherMaster.       

     Re-start all apply processes. For every OtherMaster, re-start the capture process at from the oldest_scn of the apply process at Source that applies changes from it. For Source, re-start the capture from the oldest_scn of the apply process at Destination that applies changes from Source. 
     Splitting and Merging Propagation Streams Overview 
       FIG. 13  shows an overview of a process  1300  for splitting and merging propagation streams, in accordance with an embodiment of the present invention. In step  1302 , a single propagation stream of changes from a source node is sent to multiple destination nodes. 
     In step  1304 , the progress of applying the changes at the destination nodes is monitored. In one embodiment, a monitoring process is established at each of the destination nodes to monitor the progress. In one embodiment, a monitoring process is established at a source database to monitor all propagations from the source. Whatever monitoring processes were established may forward information they collect to a process that compares information collected, such as the progress at each of the destination nodes. 
     In response to detecting a first condition at one of the destination nodes, the propagation stream is split in step  1306 . For example, a new propagation stream is established to send changes to the destination node at which the condition was detected. As an example, the condition could be that the destination node had fallen behind the other destination nodes in applying the changes by a specified amount. The amount is specified by a user through an API, in one embodiment. 
     In response to detecting a second condition at the destination node, the streams are merged in step  1308 . For example, if problems are fixed at the destination node and it catches up, or nearly catches up, with the other nodes, then the propagation streams are merged. 
     Example of Splitting and Merging a Propagation Stream 
       FIG. 8A  shows a configuration having a single propagation stream, in accordance with an embodiment. A capture process (CAP) captures changes from DBS 1 , which are propagated to DBS 2  and DBS 3 . Apply processes, APP_FOR_DBS 1 @DBS 2  and APP_FOR_DBS 1 @DBS 3 , are set up at DBS 2  and DBS 3  to apply changes from DBS 1 . For simplicity, a source queue and destination queues are not depicted in  FIG. 8 . Even though there are two propagation processes in  FIG. 8A , it is considered a single stream because the changes originate from the same capture process. If the progress of one destination database lags substantially behind the other destination database, the propagation stream can be split such that the problematic destination does not negatively impact the other destination. A reason that an offending destination could impact the other destination is that the queue either needs to hold unconsumed messages for the offending destination or spill the unconsumed messages. 
       FIG. 8B , the original propagation shown in  FIG. 8A  is split into two propagations, in accordance with an embodiment. For example, a new capture process (CLONED_CAP) has been added to capture changes that are sent to DBS 3  using new propagation process CLONED_PROP_DBS 1 _TO_DBS 3 . In one embodiment, a split-merge API computes a start_scn for the cloned capture process. In one embodiment, the start_scn of the cloned capture process (CLONED_CAP) is established as the SCN of the original capture process (CAP) at the point at which the CLONE was created. In another embodiment, the start_scn of the cloned capture process (CLONED_CAP) is established as the oldest SCN of APPLY_FOR_DBS 1 @DBS 3 . 
     Rule sets may be handled as follows. The cloned propagation may be provided with the rule set of its original propagation. If the original propagation does not have a rule set, the cloned propagation may be provided with the rule set of the original capture. The cloned capture may be provided with the rule set of the cloned propagation. 
     When problems with DBS 3  are fixed, CLONED_CAP can be started. Eventually, the split streams can be merged. For example, eventually, the progress of CLONED_CAP may catch up with CAP, or at least nearly catch up. In one embodiment, a Merge_streams API can be called to merge back the cloned propagation (CLONED_PROP_DBS 1 _TO_DBS 3 ) and restart the original capture process (CAP) from a new start_scn. 
     Determining which Changes Made at the Source Node should be Captured after Merging Streams 
       FIG. 9  illustrates a process  900  for determining which changes to objects at the source node should be captured after merging streams, in accordance with an embodiment of the present invention. For example, changes that are made to objects at the source node at or after a particular SCN are captured, in an embodiment. Process  900  can be used to determine the particular SCN. In step  902 , the progress of the apply processes at the destination nodes are compared. In one embodiment, an oldest_message_number of APP_FOR_DBS 1 @DBS 2  and APP_FOR_DBS 1 @DBS 3  are compared with each other. The oldest_message_number is the earliest message number of the transactions currently being dequeued and applied by a apply process. In one embodiment, the comparison determines the earliest of the oldest messages. 
     In step  904 , the acknowledge messages of the split propagation processes are compared. In one embodiment, the acknowledge messages are the last message acknowledged by a propagation process. In one embodiment, the comparison determines the earliest of the acknowledge messages. 
     In step  906 , the starting points of the capture processes of each branch of the split propagation are compared. In one embodiment, the start_scn of CAP and CLONED_CAP are compared with each other. A Start_scn is the message number from which the capture process will start to capture changes. In one embodiment, the comparison looks for earliest SCN. 
     In step  908 , based on the comparisons in the previous steps, a starting point for the capture process of the merged propagation is determined. The starting point is identified by an SCN, in an embodiment. In one embodiment, the messages are associated with SCNs such that a message can be compared to an SCN. For example, the higher the message number or SCN, the newer it is. In one embodiment, the comparison of step  908  determines the newest (or maximum) of the results of the comparisons of the previous steps. For example, step  908  determines the maximum of: 1) the minimum oldest_message_number from step  902 ; 2) the minimum acked_scn from step  904 ; and 3) the minimum start_scn from step  906 . This determined value is used as the start_SCN of the capture process after the merge. Thus, any changes made at or after the start_SCN will be captured and propagated in the merged stream. 
     Adding a New Object to the Information Sharing Environment 
     In one embodiment, an API can be used to add a new database object to the existing information sharing environment in accordance with an embodiment of the present invention.  FIG. 10  shows two data streams in a one-directional information sharing environment, in accordance with an embodiment of the present invention. The first data stream includes a capture process (CAP@DBS 1 ) that captures changes from DBS 1 , and an apply process (APP@DBS 2 ) that applies changes propagated from DBS 1  by a propagation (PROP). To add a new object to the information sharing environment, a second stream that is dedicated to the new object is created. In  FIG. 10 , the second stream includes NEW_CAP@DBS 1 , NEW_PROP, and NEW_APP@DBS 2 . At some point, the second stream is merged with the first stream in order to add the new object to the information sharing environment. 
       FIG. 11  describes a process  1100  for adding a new object to an information sharing environment by merging the new stream with an original stream, in accordance with an embodiment of the present invention. In step  1102 , the current SCN of the source database (e.g., DBS 1 ) is queried. The current SCN is provided as the max_scn of apply processes at DBS 2  (APP@DBS 2  and NEW_APP@DBS 2 ). The apply process will be stopped when they reach this point. 
     In step  1104 , when the apply processes at the destination stop, the oldest SCN of each is queried. There should be no un-applied transactions below the max_scn, and there should be no applied transactions above the max_scn. Otherwise, steps  1102  and  1104  are repeated. 
     In step  1106 , the capture processes at the source (CAP@DBS 1  and NEW_CAP@DBS 1 ) are stopped. In step  1108 , rules from new stream are added to the original stream. For example, all capture rules of NEW_CAP@DBS 1  are added to CAP@DBS 1 , all propagation rules of NEW_PROP are added to PROP, and all apply rules of NEW_APP@DBS 2  are added to APP@DBS 2 . Furthermore, NEW_CAP@DBS 1 , NEW_PROP, and NEW_APP@DBS 2  are dropped. 
     In step  1110 , the destination is provided with a starting point at which to apply changes from the source. All changes that were made at the source node after the starting point are to be applied at the destination node. In one embodiment, the starting point is identified by an SCN such that the destination node can identify changes that should be applied. In an embodiment, the starting point is the max_scn from step  1102 . Thus, the destination node (DBS 2 ) has a point at which changes should be applied. 
     In step  1112 , the capture process at the source is started. To determine at which point the capture process should be started, the oldest SCN of APP@DBS 2  and NEW_APP@DBS 2  from step  1104  are compared. The capture process is started at the minimum (e.g., oldest) of the oldest SCN. 
     Hardware Overview 
       FIG. 12  is a block diagram that illustrates a computer system  1200  upon which an embodiment of the invention may be implemented. Computer system  1200  includes a bus  1202  or other communication mechanism for communicating information, and a processor  1204  coupled with bus  1202  for processing information. Computer system  1200  also includes a main memory  1206 , such as a random access memory (RAM) or other dynamic storage device, coupled to bus  1202  for storing information and instructions to be executed by processor  1204 . Main memory  1206  also may be used for storing temporary variables or other intermediate information during execution of instructions to be executed by processor  1204 . Computer system  1200  further includes a read only memory (ROM)  1208  or other static storage device coupled to bus  1202  for storing static information and instructions for processor  1204 . A storage device  1210 , such as a magnetic disk or optical disk, is provided and coupled to bus  1202  for storing information and instructions. 
     Computer system  1200  may be coupled via bus  1202  to a display  1212 , such as a cathode ray tube (CRT), for displaying information to a computer user. An input device  1214 , including alphanumeric and other keys, is coupled to bus  1202  for communicating information and command selections to processor  1204 . Another type of user input device is cursor control  1216 , such as a mouse, a trackball, or cursor direction keys for communicating direction information and command selections to processor  1204  and for controlling cursor movement on display  1212 . This input device typically has two degrees of freedom in two axes, a first axis (e.g., x) and a second axis (e.g., y), that allows the device to specify positions in a plane. 
     The invention is related to the use of computer system  1200  for implementing the techniques described herein. According to one embodiment of the invention, those techniques are performed by computer system  1200  in response to processor  1204  executing one or more sequences of one or more instructions contained in main memory  1206 . Such instructions may be read into main memory  1206  from another computer-readable medium, such as storage device  1210 . Execution of the sequences of instructions contained in main memory  1206  causes processor  1204  to perform the process steps described herein. In alternative embodiments, hard-wired circuitry may be used in place of or in combination with software instructions to implement the invention. Thus, embodiments of the invention are not limited to any specific combination of hardware circuitry and software. 
     The term “computer-readable medium” as used herein refers to any medium that participates in providing instructions to processor  1204  for execution. Such a medium may take many forms, including but not limited to, non-volatile media, volatile media, and transmission media. Non-volatile media includes, for example, optical or magnetic disks, such as storage device  1210 . Volatile media includes dynamic memory, such as main memory  1206 . Transmission media includes coaxial cables, copper wire and fiber optics, including the wires that comprise bus  1202 . Transmission media can also take the form of acoustic or light waves, such as those generated during radio-wave and infra-red data communications. 
     Common forms of computer-readable media include, for example, a floppy disk, a flexible disk, hard disk, magnetic tape, or any other magnetic medium, a CD-ROM, any other optical medium, punchcards, papertape, any other physical medium with patterns of holes, a RAM, a PROM, an EPROM, a FLASH-EPROM, any other memory chip or cartridge, a carrier wave as described hereinafter, or any other medium from which a computer can read. 
     Various forms of computer readable media may be involved in carrying one or more sequences of one or more instructions to processor  1204  for execution. For example, the instructions may initially be carried on a magnetic disk of a remote computer. The remote computer can load the instructions into its dynamic memory and send the instructions over a telephone line using a modem. A modem local to computer system  1200  can receive the data on the telephone line and use an infra-red transmitter to convert the data to an infra-red signal. An infra-red detector can receive the data carried in the infra-red signal and appropriate circuitry can place the data on bus  1202 . Bus  1202  carries the data to main memory  1206 , from which processor  1204  retrieves and executes the instructions. The instructions received by main memory  1206  may optionally be stored on storage device  1210  either before or after execution by processor  1204 . 
     Computer system  1200  also includes a communication interface  1218  coupled to bus  1202 . Communication interface  1218  provides a two-way data communication coupling to a network link  1220  that is connected to a local network  1222 . For example, communication interface  1218  may be an integrated services digital network (ISDN) card or a modem to provide a data communication connection to a corresponding type of telephone line. As another example, communication interface  1218  may be a local area network (LAN) card to provide a data communication connection to a compatible LAN. Wireless links may also be implemented. In any such implementation, communication interface  1218  sends and receives electrical, electromagnetic or optical signals that carry digital data information sharing system  100  representing various types of information. 
     Network link  1220  typically provides data communication through one or more networks to other data devices. For example, network link  1220  may provide a connection through local network  1222  to a host computer  1224  or to data equipment operated by an Internet Service Provider (ISP)  1226 . ISP  1226  in turn provides data communication services through the world wide packet data communication network now commonly referred to as the “Internet”  1228 . Local network  1222  and Internet  1228  both use electrical, electromagnetic or optical signals that carry digital data information sharing system  100 . The signals through the various networks and the signals on network link  1220  and through communication interface  1218 , which carry the digital data to and from computer system  1200 , are exemplary forms of carrier waves transporting the information. 
     Computer system  1200  can send messages and receive data, including program code, through the network(s), network link  1220  and communication interface  1218 . In the Internet example, a server  1230  might transmit a requested code for an application program through Internet  1228 , ISP  1226 , local network  1222  and communication interface  1218 . 
     The received code may be executed by processor  1204  as it is received, and/or stored in storage device  1210 , or other non-volatile storage for later execution. In this manner, computer system  1200  may obtain application code in the form of a carrier wave. 
     In the foregoing specification, embodiments of the invention have been described with reference to numerous specific details that may vary from implementation to implementation. Thus, the sole and exclusive indicator of what is the invention, and is intended by the applicants to be the invention, is the set of claims that issue from this application, in the specific form in which such claims issue, including any subsequent correction. Any definitions expressly set forth herein for terms contained in such claims shall govern the meaning of such terms as used in the claims. Hence, no limitation, element, property, feature, advantage or attribute that is not expressly recited in a claim should limit the scope of such claim in any way. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense.