rhoconnect 3.0.0.beta1 → 3.0.0.beta3

data/doc/heroku-addon.txt

@@ -0,0 +1,54 @@
+Heroku Addon
+==========
+
+RhoConnect is now available for those using <a href='http://heroku.com' target='_blank'>Heroku</a> as an addon.  
+
+
+
+Adding RhoConnect from Heroku
+-----------------------
+To use RhoConnect from Heroku, install the RhoConnect add-on:
+
+	:::term
+	$ heroku addons:add rhoconnect
+	
+###Setup
+
+From inside your heroku account, setup the url to your backend service that RhoConnect will connect to.
+
+First, click the addons drop down and select rhoconnect.
+<p><img src='https://s3.amazonaws.com/rhodocs/rhoconnect-service/addon_rhoconnect.png' width="479" height="319"/></p>
+
+You will be redirected to the admin console of your RhoConnect instance where you can set the backend app url.  Select Backend App Url from the right menu.
+<p><img src='https://s3.amazonaws.com/rhodocs/rhoconnect-service/console.png' width="800" height="280"/></p>
+
+
+From here you can enter a url to your backend service.  Enter a url (for example http://myrailsapp.com), and click the add link to save the url.
+
+RhoConnect is now setup with your backend service.  
+
+Connecting a simple rhodes app
+-------------------------------
+To view a full tutorial about creating a rhodes application and the features of rhodes see [Rhodes framework](http://docs.rhomobile.com/rhodes/tutorial).
+
+###Gem installation:
+
+	:::ruby
+	[sudo] gem install rhodes
+
+Next using the rhodes gem you can create a rhodes app.   
+
+	:::ruby
+    rhodes app sample_app url_of_rhoconnect_instance
+	
+To get the value for the url_of_rhoconnect_instance argument, go to the RhoConnect console and click on the right Backend App URL link.  From there you can copy the syncserver url.
+
+<p><img src='https://s3.amazonaws.com/rhodocs/rhoconnect-service/console.png' width="800" height="280"/></p>  
+ 
+
+----
+[RhoConnect Introduction](http://docs.rhomobile.com/rhosync/introduction)
+
+[RhoConnect Installation](http://docs.rhomobile.com/rhosync/install)
+
+[RhoConnect Tutorial](http://docs.rhomobile.com/rhosync/tutorial)

data/doc/install.txt

@@ -24,5 +24,4 @@ Your RhoConnect application folder will be located in C:\RhoConnect\rhoconnect b
 To install the RhoConnect gem, run:
 
 	:::term
-  	$ [sudo] gem install rhoconnect --pre
- 
+  	$ [sudo] gem install rhoconnect --pre

data/doc/migration.txt

@@ -19,14 +19,25 @@ Create a new `Gemfile` file in your application directory with the following con
 
 	gem 'rhoconnect', '3.0.0'
 
+	# Helps with some of the limitations of green threads, not needed in ruby 1.9.x
+	gem 'SystemTimer', '~> 1.2.3', :platforms => :ruby_18
+
+	platforms :jruby do
+	  gem 'jdbc-sqlite3', ">= 3.7.2"
+	  gem 'dbi', ">= 0.4.5"
+	  gem 'dbd-jdbc', ">= 0.1.4"
+	  gem 'jruby-openssl', ">= 0.7.4"
+	  gem 'warbler'
+	end
+
+	gem 'sqlite3', ">= 1.3.3", :platforms => [:ruby, :mswin, :mingw]
+
+	# For jruby trinidad JRuby web server is used
+	gem 'trinidad',  :platforms => :jruby
+
 	group :development do
 	  # By default to run application thin web server is used
-	  gem 'thin', '1.2.11', :platforms => :ruby
-
-	  # For jruby trinidad JRuby web server is used
-	  gem 'trinidad',  :platforms => :jruby
-	  # Alternative for jruby
-	  # gem 'jetty-rackup',  :platforms => :jruby
+	  gem 'thin', :platforms => [:ruby, :mswin, :mingw]
 	end
 
 	group :test do
@@ -34,6 +45,7 @@ Create a new `Gemfile` file in your application directory with the following con
 	  gem 'rspec', '~> 2.6.0'
 	  gem 'rcov', '>= 0.9.8'
 	end
+	
 
 ## Edit the Rakefile
 

data/doc/net-plugin.txt

@@ -0,0 +1,276 @@
+rhoconnect.NET
+===
+
+A .NET 4 framework library for the [Rhoconnect](http://rhomobile.com/products/rhosync) App Integration Server.
+
+Using rhoconnect.NET, your [ASP.NET MVC3](http://www.asp.net/mvc/mvc3) application's data will transparently synchronize with a mobile application built on the [Rhodes framework](http://rhomobile.com/products/rhodes), or any of the available [Rhoconnect clients](http://rhomobile.com/products/rhosync/).
+
+## Getting started
+
+Copy the [`rhoconnect.NET`](https://github.com/rhomobile/rhoconnect.NET) github repository to your PC:
+
+	$ git clone git@github.com:rhomobile/rhoconnect.NET.git
+
+By default, the `rhoconnect.NET` repository contains the pre-built `RhoconnectNET.dll` library in the `bin/Release` subdirectory.
+However, you can build your own library using the provided Microsoft Visual Studio .NET solution file and the source code files. 
+
+In order to use `Rhoconnect.NET` functionality in your `ASP.NET MVC 3` application, first you need to include the `Rhoconnect.NET` library 
+as a dependency to your application. Click `Project => Add Reference` menu item in the Visual Studio and navigate to the `RhoconnectNET.dll` library.
+After this step is completed, you can add references to the `Rhoconnect.NET` namespace into the application's and Controller's files:
+
+	using RhoconnectNET;
+	using RhoconnectNET.Controllers;
+
+
+## Registering `Rhoconnect.NET` routes for your application
+
+To establish the communication channel between ASP.NET MVC 3 application and Rhoconnect server, 
+you need to implement the following `init_rhoconnect` and `rhoconnect_authenticate` methods in the `Global.asax.cs` file 
+and call them from the `Application_Start` method:
+
+	protected void Application_Start()
+	{
+		... ASP.NET initialization routines ...
+		... typically, registering routes and filters is done here ...
+		
+		// after app is properly initialized
+		// call RhoconnectNET initialization
+		init_rhoconnect();
+	}
+	
+	// implement init_rhoconnect() method to establish
+	// communication link between `Rhoconnect` server
+	// and ASP.NET MVC 3 application
+	const bool init_rhoconnect()
+	{
+		// this call allows parsing JSON structures into Objects
+		ValueProviderFactories.Factories.Add(new JsonValueProviderFactory());
+		
+		// this call establishes communication between Rhoconnect and ASP.NET application
+		// as a last parameter we supply authentication routine that will called 
+		// by rhoconnect server to authenticate users.
+		RhoconnectNET.Client.set_app_endpoint("my_rhoconnect_server_url", 
+											  "my_mvc_app_root_url", 
+											  "rhoconnect_api_token", 
+											  rhoconnect_authenticate);
+	}
+	
+	const bool rhoconnect_authenticate(String username, String password, Hashtable params)
+	{
+		// perform your authentication here
+		return true;
+	}
+	
+`RhoconnectNET.Client.set_app_point` method is a main point
+in establishing the communication link between `Rhoconnect` server and the ASP.NET MVC 3 application
+and it has the following parameters:
+
+<table border="1">
+	<tr>
+		<td>String</td>
+		<td><code>rhoconnect_url</code></td>
+		<td>rhoconnect server's url, for example <code>http://localhost:9292</code>.</td>
+	</tr>
+	<tr>
+		<td>String</td>
+		<td><code>app_endpoint</code></td>
+		<td>your MVC app url, for example <code>http://my_pc_host/MyApp</code>.</td>
+	</tr>
+	<tr>
+		<td>String</td>
+		<td><code>api_token</code></td>
+		<td>rhoconnect server's api_token, for example <code>secrettoken</code>.</td>
+	</tr>
+	<tr>
+		<td>Func&lt;String, String, Hashtable, bool&gt;</td>
+		<td><code>Authenticating_Routine</code></td>
+		<td>handle to the application's authenticating routine (if null, <code>true</code> is returned by default).</td>
+	</tr>
+</table>
+
+`Rhoconnect.NET` installs a `/rhoconnect/authenticate` route into your application which will receive credentials from the client.  
+By providing the `rhoconnect_authenticate` method and registering it with the `Rhoconnect.NET` in the `set_app_endpoint`
+method, you map your application specific authentication to the Rhoconnect `authenticate` requests:
+
+	const bool rhoconnect_authenticate(String username, String password, Hashtable params)
+	{
+		// perform real authentication here
+		return true;
+	}
+
+## Implementing CRUD functionality
+`Rhoconnect.NET` lib installs `/rhoconnect/<CRUD>` routes in your application which the Rhoconnect instance 
+invokes to perform CRUD operations on the data for the dataset you want to synchronize.
+Each of the routes is mapped to a corresponding `rhoconnect_<operation>` method in the **IRhoconnectCRUD** interface
+which you must implement in the dataset's Controller class.
+
+		public class MyDataController : Controller, IRhoconnectCRUD
+		{
+			... implementation of Controller routes
+	
+			// next four methods must be implemented
+			// and will be called by Rhoconnect server
+			JsonResult rhoconnect_query_objects(String partition);
+			ActionResult rhoconnect_create(String objJson, String partition);
+			ActionResult rhoconnect_update(Dictionary<string, object> changes, String partition);
+			ActionResult rhoconnect_delete(Object objId, String partition);
+		} 
+
+## Query the datasets
+The route `/rhoconnect/query` is mapped to the `rhoconnect_query_objects` method of the **IRhoconnectCRUD**
+interface that you must implement in the corresponding dataset's Controller class. It must
+return a collection of source objects in the form of a JsonResult:
+
+		JsonResult rhoconnect_query_objects(String partition)
+		{
+			return Json(db.Products.ToDictionary("id"));
+		}
+	
+In the above example, the Products object set is converted to `Dictionary<String, Object>`
+where the dictionary's key must correspond to an unique object's `id` field.
+After dictionary is created , it is converted to JsonResult and sent to the Rhoconnect server.
+
+## Create new objects
+The route `/rhoconnect/create` is mapped to the `rhoconnect_create` method of the IRhoconnectCRUD
+interface that you must implement in the corresponding dataset's Controller class. It should
+return a newly created object's id in case of success:
+
+		public ActionResult rhoconnect_create(String objJson, String partition)
+        {
+            Product new_product = (Product)RhoconnectNET.Helpers.deserialize_json(objJson, typeof(Product));
+            db.Products.AddObject(new_product);
+            db.SaveChanges();
+            return RhoconnectNET.Helpers.serialize_result(new_product.id);
+        }
+	
+## Update existing objects
+In the similar fashion, the route `/rhoconnect/update` is mapped to the `rhoconnect_update` method of the IRhoconnectCRUD
+interface that you must implement in the corresponding dataset's Controller class. It should
+return an updated object's id in case of success:
+
+		public ActionResult rhoconnect_update(Dictionary<string, object> changes, String partition)
+        {
+            String obj_id = changes["id"]);
+            Product product_to_update = db.Products.First(p => p.id == obj_id); 
+		    // this method will update only the modified fields
+            RhoconnectNET.Helpers.merge_changes(product_to_update, changes);
+            db.ObjectStateManager.ChangeObjectState(product_to_update, EntityState.Modified);
+            db.SaveChanges();
+            return RhoconnectNET.Helpers.serialize_result(obj_id); 
+        }
+
+## Delete objects from the dataset
+The route `/rhoconnect/delete` is mapped to the `rhoconnect_delete` method of the IRhoconnectCRUD
+interface that you must implement in the corresponding dataset's Controller class. It should
+return a deleted object's id in case of success:
+
+        public ActionResult rhoconnect_delete(Object objId, String partition)
+        {
+            String key = objId.ToString();
+
+            Product product_to_delete = db.Products.Single(p => p.id == key);
+            db.Products.DeleteObject(product_to_delete);
+            db.SaveChanges();
+            return RhoconnectNET.Helpers.serialize_result(objId);
+        }
+
+## Partitioning Datasets
+Each of the above methods have a partition key supplied with the CRUD request.	This partition key is used by `Rhoconnect` to uniquely identify the model dataset when it is stored in a rhoconnect instance.  It is typically an attribute on the model or related model.  `Rhoconnect` supports two types of partitions:
+
+* :app - No unique key will be used, a shared dataset is synchronized for all users.
+* lambda { some lambda } - Execute a lambda which returns the unique key string.
+
+For example, the `Product` model above might have a relationship to the User model.  This provides us a simple way to organize the `Product` dataset for rhoconnect by reusing this relationship.  
+In this case, your implementation might filter out data on a per user basis.
+	
+For more information about Rhoconnect partitions, please refer to the [Rhoconnect docs](http://docs.rhomobile.com/rhosync/source-adapters#data-partitioning).
+
+## Implementing MVC callbacks
+All of the above methods are necessary to establish the communication from the Rhoconnect instance to your ASP.NET MVC application. 
+However, to complete the implementation, it is necessary to implement a reverse way to notify the Rhoconnect instance about the changes made in your MVC app.
+Typically, your MVC Controller class reacts to the actions by implementing the CRUD POST routes, for example:
+
+		[HttpPost]
+		public ActionResult Create(Product new_product)
+		{
+		     if (ModelState.IsValid)
+		     {
+                db.Product.AddObject(new_product);
+                db.SaveChanges();
+                return RedirectToAction("Index");  
+              }
+
+            return View(new_product);
+        }
+
+Here, you need to insert a call which will notify the Rhoconnect instance that a new object has been created.
+For this reason, `RhoconnectNET` library provides three callback routines for CUD notifications.
+The above example will look like this after inserting the corresponding callback routine:
+
+		[HttpPost]
+	    public ActionResult Create(Product product)
+	    {
+		     if (ModelState.IsValid)
+		     {
+                db.Product.AddObject(product);
+                db.SaveChanges();
+
+				// insert these lines to provide
+				// notifications to Rhoconnect server
+				Hashtable reqHash = new Hashtable();
+                reqHash.Add(new_product.id.ToString(), new_products);
+                RhoconnectNET.Client.notify_on_create("Product", "partition_string", reqHash);
+
+                return RedirectToAction("Index");  
+              }
+
+              return View(new_product);
+        }
+
+In the example above, user need to call `RhoconnectNET.Client.notify_on_create` method 
+with the following parameters:
+
+- String rhoconnect_source_name : dataset's name
+- String rhoconnect_partition : partition to which the object belongs (see above section "Partitioning datasets")
+- Hashtable<String, Object> object_hash : Hashtable with object's id as a key and the object itself as a value
+
+In the same fashion , your dataset's Controller need to implement `Edit` and `Delete` callback notifications:
+
+		[HttpPost]
+        public ActionResult Edit(Product product)
+        {
+            if (ModelState.IsValid)
+            {
+                db.Products.Attach(product);
+                db.ObjectStateManager.ChangeObjectState(product, EntityState.Modified);
+                db.SaveChanges();
+				
+				// insert this callback to notify Rhoconnect
+				// about the update operation
+                Hashtable reqHash = new Hashtable();
+                reqHash.Add(product.id.ToString(), product);
+                RhoconnectNET.Client.notify_on_update("Product", "partition_string", reqHash);
+
+                return RedirectToAction("Index");
+            }
+            return View(product);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        public ActionResult DeleteConfirmed(String id)
+        {            
+            Product product = db.Products.Single(p => p.id == id);
+            db.Products.DeleteObject(product);
+            db.SaveChanges();
+
+			// insert this callback to notify Rhoconnect
+			// about the delete operation
+            RhoconnectNET.Client.notify_on_delete("Product", rhoconnect_partition(), id);
+
+            return RedirectToAction("Index");
+        }
+
+## Meta
+Created and maintained by Maxim Zverev.
+
+Released under the [MIT License](http://www.opensource.org/licenses/mit-license.php).

data/doc/plugin-intro.txt

@@ -0,0 +1,6 @@
+RhoConnect Plugins Introduction
+===
+
+Rhoconnect Plugins allow you to connect your backend apps seamlessly with rhoconnect.  
+
+<img src='https://s3.amazonaws.com/rhodocs/rhoconnect-service/intro-plugin.png' alt='image' height='467' width='800' />

data/doc/push.txt

@@ -48,7 +48,7 @@ To setup your RhoConnect application for Android push, you will need to update `
 
 Replace `:authtoken:` value with actual authentication token. This token MUST be related to the role-based google account registered for your application. See [the rhodes push instructions](/rhodes/device-caps#push-notifications) for more details. To retrieve this token, use sample script [c2dm.rb](http://github.com/rhomobile/rhodes/blob/master/bin/c2dm.rb). Uncomment last two lines and put your google account specific data, then run it. It will print token to stdout.
 
-For those who interested in what this token means, here is the description: <a href="http://code.google.com/apis/accounts/docs/AuthForInstalledApps.html"/>.
+For those who interested in what this token means, the description is [here](http://code.google.com/apis/accounts/docs/AuthForInstalledApps.html).
 
 Now start up your RhoConnect application and setup [push notifications](/rhodes/device-caps#push-notifications) in your Rhodes application.
 

data/doc/rails-plugin.txt

@@ -0,0 +1,116 @@
+rhoconnect-rb
+===
+
+A ruby library for the [Rhoconnect](http://rhomobile.com/products/rhosync) App Integration Server.
+
+Using rhoconnect-rb, your application's model data will transparently synchronize with a mobile application built on the [Rhodes framework](http://rhomobile.com/products/rhodes), or any of the available [Rhoconnect clients](http://rhomobile.com/products/rhosync/).  This client includes built-in support for [ActiveRecord](http://ar.rubyonrails.org/) and [DataMapper](http://datamapper.org/) models.
+
+## Getting started
+
+Load the `rhoconnect-rb` library:
+
+	require 'rhoconnect-rb'
+
+Note, if you are using datamapper, install the `dm-serializer` library and require it in your application.  `rhoconnect-rb` depends on this utility to interact with Rhoconnect applications using JSON.
+	
+## Usage
+Now include Rhoconnect::Resource in a model that you want to synchronize with your mobile application:
+
+	class Product < ActiveRecord::Base
+	  include Rhoconnect::Resource
+	end
+	
+Or, if you are using DataMapper:
+
+	class Product
+	  include DataMapper::Resource
+	  include Rhoconnect::Resource
+	end
+
+### Partitioning Datasets
+	
+Next, your models will need to declare a partition key for `rhoconnect-rb`.  This partition key is used by `rhoconnect-rb` to uniquely identify the model dataset when it is stored in a rhoconnect instance.  It is typically an attribute on the model or related model.  `rhoconnect-rb` supports two types of partitions:
+
+* :app - No unique key will be used, a shared dataset is synchronized for all users.
+* lambda { some lambda } - Execute a lambda which returns the unique key string.
+
+For example, the `Product` model above might have a `belongs_to :user` relationship.  This provides us a simple way to organize the `Product` dataset for rhoconnect by reusing this relationship.  The partition identifying a username would be declared as:
+
+	class Product < ActiveRecord::Base
+	  include Rhoconnect::Resource
+	  
+	  belongs_to :user
+	
+	  def partition 
+		lambda { self.user.username }
+	  end
+	end
+	
+Now all of the `Product` data synchronized by rhoconnect will organized by `self.user.username`.  Note: You can also used a fixed key if the dataset doesn't require a dynamic value:
+
+	def partition
+	  :app
+	end
+	
+For more information about Rhoconnect partitions, please refer to the [Rhoconnect docs](http://docs.rhomobile.com/rhosync/source-adapters#data-partitioning).
+
+### Querying Datasets
+
+`rhoconnect-rb` installs a `/rhoconnect/query` route in your application which the Rhoconnect instance invokes to query the dataset for the dataset you want to synchronize.  This route is mapped to a `rhoconnect_query` method in your model.  This method should return a collection of objects:
+
+	class Product < ActiveRecord::Base
+	  include Rhoconnect::Resource
+	  
+	  belongs_to :user
+	
+	  def partition 
+		lambda { self.user.username }
+	  end
+	
+	  def self.rhoconnect_query(partition)
+	    Product.where(:user_id => partition)
+	  end
+	end
+
+In this example, `self.rhoconnect_query` returns a list of products where the partition string (provided by the rhoconnect instance) matches the `user_id` field in the products table.  
+
+### Configuration and Authentication
+
+Configure Rhoconnect in an initializer like `config/initializers/rhoconnect.rb` (for Rails), or directly in your application (i.e. Sinatra).  Here you will setup the rhoconnect uri (the location of your rhoconnect instance), and app\_endpoint (the location of your ruby app):
+
+
+	# Use rhoconnect:get_token to get the token value.
+	
+	config.uri   = "http://myrhoconnect.com"
+	config.token = "secrettoken"
+	config.app_endpoint = "http://myapp.heroku.com"
+	
+If `app_endpoint` is defined, your Rhoconnect instance will be configured to query data from the endpoint using the rhoconnect_query method in your model.  For example, if your `app_endpoint` is defined as "http://myapp.heroku.com", Rhoconnect will query data with:
+
+	POST http://myapp.heroku.com/rhoconnect/query
+
+Example: 
+
+   	Rhoconnect.configure do |config|
+      config.uri   		  = "http://myrhoconnect-server.com"
+      config.token 		  = "secrettoken"
+	  config.app_endpoint = "http://myapp.heroku.com"
+	end
+	
+Example with authentication:
+
+`rhoconnect-rb` installs a `/rhoconnect/authenticate` route into your application which will receive credentials from the client.  Add block which handles the credentials:
+
+	Rhoconnect.configure do |config|
+      config.uri   = "http://myrhoconnect-server.com"
+      config.token = "secrettoken"
+	  config.authenticate = lambda { |credentials| 
+        User.authenticate(credentials[:login], credentials[:password]) 
+	  }
+	end
+	
+
+## Meta
+Created and maintained by Lucas Campbell-Rossen, Vladimir Tarasov and Lars Burgess.
+
+Released under the [MIT License](http://www.opensource.org/licenses/mit-license.php).

data/doc/rest-api.txt

@@ -69,7 +69,7 @@ Reset the server: flush db and re-bootstrap server
     )
 
 ### `ping`
-Sends PUSH message to all devices of the specified user:
+Sends PUSH message to all devices of the specified user(s):
 
 	:::ruby
 	# :message - message which will be used to display notification popup dialog on the device
@@ -79,7 +79,7 @@ Sends PUSH message to all devices of the specified user:
 	# :sources - list of data source names to be synced upon receiving PUSH notification
 	ping_params = {
       :api_token => token,
-      :user_id => user_id,
+      :user_id => [array_of_users],
       :sources => source_name,
       :message => 'hello world',
       :vibrate => 2000,

data/doc/settings.txt

@@ -0,0 +1,59 @@
+RhoConnect settings
+===
+
+All Rhoconnect application and source settings located in the *`settings/settings.yml`* file.
+There are two main categories: application environment settings and source settings.
+
+## Application settings
+
+Application-wide settings are specified per deployment environment (`:test`, `:development`, `:production`).
+Each of the environment categories must have the following entries:
+	
+	:::yaml
+	:syncserver: <url> - application's base url
+	:redis: <url> - Redis url
+	:licensefile: <filename> - application's license file
+	
+In addition, the following settings can be specified:
+
+	:::yaml
+	:poll_interval_default: <secs> - default sync poll interval setting for source adapters.
+									 This setting is used as a default if source doesn't specify
+									 its own value. Also, it is applied to dynamic adapters
+									 as a default sync poll interval.
+	:bulk_data_poll_interval: <secs> - poll interval setting for bulk data sync
+	
+## Source settings
+
+All source-specific settings are specified under the corresponding source name entry in the `:sources` category.
+Typical source settings include:
+
+	:::yaml
+	:poll_interval: <secs> - source's sync poll interval.
+	:force_default: <true|false> - if specified, this setting forces to use 
+									 default application poll interval
+								     even if source has its own setting.
+    :partition_type: <app|user> - default partition type for the source
+	:retry_limit: <number_of_retries> - this option allows to for the user to 
+									    perform sync upto <number_of_retries> times
+									    in case of previous sync failure. 
+										Normally, each sync resets the refresh time
+										according to the polling interval regardless
+										of the sync success or failure. In case of failure,
+										it may not be a desired scenario because user will
+										be getting an error on all sync attempts until 
+										the next polling interval will expire. This setting
+										allows to overcome this issue.The following flow
+										shows the algorithm in place:
+										
+										1) If sync fails and :retry_limit is set to N > 0,
+											refresh_time is not updated for next N retries (or until any of them succeeds). 
+											Here 'retry' means that user will be able to initiate another sync request 
+											(since refresh_time is not updated).
+
+										2) If one of the retry succeeds - source's refresh time is updated and retry counter is reset.
+										3) If the `:retry_limit` is reached and all attempts have failed - 
+											source's refresh time is updated to prevent excessive polling on the permanently down backend. 
+										4) Also, if more then `:poll_interval` seconds has elapsed 
+											since last refresh_time - source's retry counter is reset.
+	

data/doc/tutorial.txt

@@ -18,11 +18,16 @@ Now you are ready to write your RhoConnect app.  You can generate an app with th
 	:::term
 	$ rhoconnect app storemanager-server
 	$ cd storemanager-server/
+	
+Next, install the application's dependencies.  RhoConnect applications use [bundler](http://gembundler.com/) to manage dependencies, so you can install them with:
+
+	:::term
+	$ [sudo] bundle install
 
 **If you are running this for the first time on Mac or Linux**, you will need to install [dtach](http://dtach.sourceforge.net/):
 
 	:::term
-	$ sudo rake dtach:install  
+	$ [sudo] rake dtach:install  
 
 ### Verify Installation
 
@@ -36,8 +41,6 @@ If everything went well you should see:
 
 	[07:01:15 PM 2010-05-04] Rhoconnect Server v3.0.0 started...
 
-**NOTE: You will be prompted to edit the session secret in your config.ru to something other than "\<changeme\>"**
-
 Defining RhoConnect Source Adapters
 ---
 
@@ -164,9 +167,9 @@ We need to declare the standard libraries that we are using at the top of the fi
 For convenience, we'll add an instance variable @base which contains the base URL of the web service and set the value in the constructor:
 
 	:::ruby
-  	def initialize(source,credential)
+  	def initialize(source)
       @base = 'http://rhostore.heroku.com/products'
-      super(source,credential)
+      super(source)
     end
 
 Then fill in the query method: