quartz_flow 0.0.3 → 0.0.4

data/etc/quartz.rb

@@ -7,10 +7,10 @@ set :bind, "0.0.0.0"
 set :port, 4444
 
 # Directory where downloaded torrent data will be stored
-set :basedir, "/mnt/twotb/movies" 
+set :basedir, "download" 
 
 # Directory where .torrent files and .info files will be stored.
-set :metadir, "meta" 
+set :metadir, "meta"
 
 # TCP port used for torrents
 set :torrent_port, 9997
@@ -23,3 +23,10 @@ set :torrent_log, "log/torrent.log"
 
 # On which day of the month should monthly usage tracking reset
 set :monthly_usage_reset_day, 5
+
+# Torrent Queueing settings. 
+# Max number of active torrents is the max number of torrents that can be running at once.
+# Max number of incomplete torrents is a subset of the max active torrents, and describes
+# the max number of torrents that can be running that are not uploading.
+set :torrent_queue_max_active, 10
+set :torrent_queue_max_incomplete, 5

data/lib/quartz_flow/server.rb

@@ -46,6 +46,8 @@ class Server < Sinatra::Base
     set :password_file, "etc/passwd"
     set :logging, true
     set :monthly_usage_reset_day, 1
+    set :torrent_queue_max_incomplete, 5
+    set :torrent_queue_max_active, 10
 
     # Load configuration settings
     eval File.open("./etc/quartz.rb","r").read
@@ -72,9 +74,13 @@ class Server < Sinatra::Base
       setDefaultLevel :info
     end
     LogConfigurator.configLevels
-    peerClient = QuartzTorrent::PeerClient.new(settings.basedir)
+    peerClient = QuartzTorrent::PeerClient.new(settings.basedir, settings.torrent_queue_max_incomplete, settings.torrent_queue_max_active)
     peerClient.port = settings.torrent_port
-    peerClient.start
+    begin
+      peerClient.start
+    rescue Errno::EADDRINUSE
+      raise "Starting torrent peer failed because listening on port #{settings.torrent_port} failed: " + $!.message
+    end
 
     # Initialize Datamapper
     #DataMapper::Logger.new($stdout, :debug)
@@ -211,13 +217,15 @@ class Server < Sinatra::Base
     begin
       $manager.storeMagnet(magnet)
     rescue
+      puts "Storing magnet link failed: #{$!}"
+      puts $!.backtrace.join("\n")
       halt 500, "Storing magnet link failed: #{$!}."
     end
    
     begin
       $manager.startMagnet(magnet)
     rescue
-      puts $!
+      puts "Starting magnet link failed: #{$!}"
       puts $!.backtrace.join("\n")
       halt 500, "Starting magnet link failed: #{$!}."
     end
@@ -254,7 +262,7 @@ class Server < Sinatra::Base
 
     infoHash = json["infohash"]
     halt 500, "Pausing torrent failed: no infohash parameter was sent to the server in the post request." if !infoHash || infoHash.length == 0
-    $manager.peerClient.setPaused QuartzTorrent::hexToBytes(infoHash), true
+    $manager.setTorrentPaused infoHash, true
     puts "Pausing torrent"
     "OK"
   end
@@ -264,7 +272,7 @@ class Server < Sinatra::Base
 
     infoHash = json["infohash"]
     halt 500, "Unpausing torrent failed: no infohash parameter was sent to the server in the post request." if !infoHash || infoHash.length == 0
-    $manager.peerClient.setPaused QuartzTorrent::hexToBytes(infoHash), false
+    $manager.setTorrentPaused infoHash, false
     "OK"
   end
 

data/lib/quartz_flow/settings_helper.rb

@@ -103,6 +103,24 @@ class SettingsHelper
       @@saveFilterForDuration,
       Proc.new{ |v| QuartzTorrent::Formatter.formatTime(v) }
     ),
+    :paused => SettingMetainfo.new(
+      :paused,
+      :torrent,
+      Proc.new{ |v| v.to_s },
+      Proc.new{ |v| v.downcase == "true" }
+    ),
+    :bytesUploaded => SettingMetainfo.new(
+      :bytesUploaded,
+      :torrent,
+      Proc.new{ |v| v.to_s },
+      Proc.new{ |v| v.to_i }
+    ),
+    :bytesDownloaded => SettingMetainfo.new(
+      :bytesDownloaded,
+      :torrent,
+      Proc.new{ |v| v.to_s},
+      Proc.new{ |v| v.to_i }
+    ),
   }
 
   def set(settingName, value, owner = nil)

data/lib/quartz_flow/torrent_manager.rb

@@ -8,6 +8,7 @@ class TorrentManager
   def initialize(peerClient, torrentFileDir, monthlyResetDay)
     @peerClient = peerClient
     @cachedTorrentData = nil
+    @cachedTorrentDataMutex = Mutex.new
     @cachedAt = nil
     @cacheLifetime = 2
     @torrentFileDir = torrentFileDir
@@ -15,22 +16,28 @@ class TorrentManager
     @usageTracker = UsageTracker.new(monthlyResetDay)
     # Start a thread to keep track of usage.
     startUsageTrackerThread
+    startTorrentDataThread
   end
 
   attr_reader :peerClient
 
   def torrentData(infoHash = nil)
-    if (! @cachedTorrentData || Time.new - @cachedAt > @cacheLifetime) && ! @peerClientStopped
-      @cachedTorrentData = @peerClient.torrentData
-      @cachedAt = Time.new
+    result = nil
+
+    # The first time, we may need to wait for the thread to load the data.
+    sleep(0.25) while ! @cachedTorrentData
+
+    @cachedTorrentDataMutex.synchronize do
+      result = @cachedTorrentData 
     end
-    
-    @cachedTorrentData
+    result
   end
 
   def stopPeerClient
     @peerClient.stop
     @peerClientStopped = true
+    stopTorrentDataThread
+    stopUsageTrackerThread
   end
 
   # Start torrents that already exist in the torrent file directory
@@ -102,11 +109,15 @@ class TorrentManager
       h[:uploadRateLimit] = QuartzTorrent::Formatter.formatSpeed(h[:uploadRateLimit])
       h[:downloadRateLimit] = QuartzTorrent::Formatter.formatSize(h[:downloadRateLimit])
       h[:bytesUploaded] = QuartzTorrent::Formatter.formatSize(h[:bytesUploaded])
+      h[:bytesDownloaded] = QuartzTorrent::Formatter.formatSize(h[:bytesDownloaded])
       h[:uploadDuration] = QuartzTorrent::Formatter.formatTime(h[:uploadDuration]) if h[:uploadDuration]
 
       h[:completePieces] = d.completePieceBitfield ? d.completePieceBitfield.countSet : 0
       h[:totalPieces] = d.completePieceBitfield ? d.completePieceBitfield.length : 0
 
+      # Only send 8 alarms
+      h[:alarms] = h[:alarms].first(8)
+
       if where
         matches = true
         where.each do |k,v|
@@ -222,6 +233,15 @@ class TorrentManager
     FileUtils.rm magnetFile if File.exists?(magnetFile)
   end
 
+  # Pause or unpause the specified torrent. Store the pause state in the database.
+  def setTorrentPaused(infoHash, val)
+    infoHashBytes = QuartzTorrent::hexToBytes(infoHash)
+    @peerClient.setPaused infoHashBytes, val
+
+    helper = SettingsHelper.new    
+    helper.set :paused, val, infoHash
+  end
+  
   # Update the torrent settings (upload rate limit, etc) from database values
   def applyTorrentSettings(infoHash)
     asciiInfoHash = QuartzTorrent::bytesToHex(infoHash)
@@ -241,10 +261,18 @@ class TorrentManager
     uploadDuration = helper.get(:defaultUploadDuration, :unfiltered) if ! uploadDuration
     uploadDuration = uploadDuration.to_i if uploadDuration
 
+    paused = helper.get(:paused, :filter, asciiInfoHash)
+
+    bytesDownloaded = helper.get(:bytesDownloaded, :filter, asciiInfoHash)
+    bytesUploaded = helper.get(:bytesUploaded, :filter, asciiInfoHash)
+
     @peerClient.setUploadRateLimit infoHash, uploadRateLimit
     @peerClient.setDownloadRateLimit infoHash, downloadRateLimit
     @peerClient.setUploadRatio infoHash, ratio
     @peerClient.setUploadDuration infoHash, uploadDuration
+    @peerClient.setPaused infoHash, paused
+    @peerClient.adjustBytesDownloaded infoHash, bytesDownloaded if bytesDownloaded
+    @peerClient.adjustBytesUploaded infoHash, bytesUploaded if bytesUploaded
   end
 
   # Get the usage for the current period of the specified type.
@@ -274,6 +302,7 @@ class TorrentManager
       QuartzTorrent.initThread("torrent_usage_tracking")
       
       Thread.current[:stopped] = false
+      helper = SettingsHelper.new
 
       while ! Thread.current[:stopped]
         begin
@@ -282,6 +311,9 @@ class TorrentManager
           usage = 0
           torrentData.each do |k,v|
             usage += v.bytesUploaded + v.bytesDownloaded
+            asciiInfoHash = QuartzTorrent::bytesToHex(k)
+            helper.set :bytesDownloaded, v.bytesDownloaded, asciiInfoHash
+            helper.set :bytesUploaded, v.bytesUploaded, asciiInfoHash
           end
           @usageTracker.update(usage)
         rescue
@@ -291,4 +323,42 @@ class TorrentManager
       end
     end
   end
+
+  def stopUsageTrackerThread
+    @usageTrackerThread[:stopped] = true
+  end
+
+  # Start a thread to update torrent data
+  def startTorrentDataThread
+    @torrentDataThread = Thread.new do
+      QuartzTorrent.initThread("torrent_data_loader")
+      
+      Thread.current[:stopped] = false
+
+      while ! Thread.current[:stopped]
+        begin
+          timer = Time.new
+          if (! @cachedTorrentData || Time.new - @cachedAt > @cacheLifetime) && ! @peerClientStopped
+            data = @peerClient.torrentData
+            @cachedTorrentDataMutex.synchronize do
+              @cachedTorrentData = data
+              @cachedAt = Time.new
+            end
+          end
+          timer = Time.new - timer
+
+          if timer < @cacheLifetime
+            sleep @cacheLifetime-timer
+          end
+        rescue
+          puts "Error in torrent data loader thread: #{$!}"
+          puts $!.backtrace.join "\n"
+        end
+      end
+    end
+  end
+
+  def stopTorrentDataThread
+    @torrentDataThread[:stopped] = true
+  end
 end

data/lib/quartz_flow/usagetracker.rb

@@ -191,7 +191,9 @@ class MonthlyBucketChangeCriteria < BucketChangeCriteria
   def criteriaData
     now = Time.new
     nextMonth = now.mon % 12 + 1
-    Time.local(now.year, nextMonth, @resetDay)
+    year = now.year
+    year += 1 if nextMonth == 1
+    Time.local(year, nextMonth, @resetDay)
   end
 end
 

data/lib/quartz_flow/wrappers.rb

@@ -51,6 +51,15 @@ module QuartzTorrent
     end
   end
 
+  class Alarm
+    def to_h
+      result = {}
+      result[:details] = @details
+      result[:time] = @time
+      result
+    end
+  end
+
   class TorrentDataDelegate
     # Convert to a hash. Also flattens some of the data into new fields.
     def to_h
@@ -70,6 +79,8 @@ module QuartzTorrent
           0
         end
       end
+      # Cap estimated time at 9999 hours
+      secondsLeft = 35996400 if secondsLeft > 35996400
       result[:timeLeft] = Formatter.formatTime(secondsLeft)
 
       ## Regular fields
@@ -87,12 +98,14 @@ module QuartzTorrent
       result[:metainfoLength] = @metainfoLength
       result[:metainfoCompletedLength] = @metainfoCompletedLength
       result[:paused] = @paused
+      result[:queued] = @queued
       result[:uploadRateLimit] = @uploadRateLimit
       result[:downloadRateLimit] = @downloadRateLimit
       result[:ratio] = @ratio
       result[:uploadDuration] = @uploadDuration
       result[:bytesUploaded] = @bytesUploaded
       result[:bytesDownloaded] = @bytesDownloaded
+      result[:alarms] = @alarms.collect{ |a| a.to_h }
 
       result
     end

data/public/js/angular-resource.js

@@ -0,0 +1,457 @@
+/**
+ * @license AngularJS v1.0.8
+ * (c) 2010-2012 Google, Inc. http://angularjs.org
+ * License: MIT
+ */
+(function(window, angular, undefined) {
+'use strict';
+
+/**
+ * @ngdoc overview
+ * @name ngResource
+ * @description
+ */
+
+/**
+ * @ngdoc object
+ * @name ngResource.$resource
+ * @requires $http
+ *
+ * @description
+ * A factory which creates a resource object that lets you interact with
+ * [RESTful](http://en.wikipedia.org/wiki/Representational_State_Transfer) server-side data sources.
+ *
+ * The returned resource object has action methods which provide high-level behaviors without
+ * the need to interact with the low level {@link ng.$http $http} service.
+ *
+ * # Installation
+ * To use $resource make sure you have included the `angular-resource.js` that comes in Angular 
+ * package. You can also find this file on Google CDN, bower as well as at
+ * {@link http://code.angularjs.org/ code.angularjs.org}.
+ *
+ * Finally load the module in your application:
+ *
+ *        angular.module('app', ['ngResource']);
+ *
+ * and you are ready to get started!
+ *
+ * @param {string} url A parameterized URL template with parameters prefixed by `:` as in
+ *   `/user/:username`. If you are using a URL with a port number (e.g. 
+ *   `http://example.com:8080/api`), you'll need to escape the colon character before the port
+ *   number, like this: `$resource('http://example.com\\:8080/api')`.
+ *
+ * @param {Object=} paramDefaults Default values for `url` parameters. These can be overridden in
+ *   `actions` methods.
+ *
+ *   Each key value in the parameter object is first bound to url template if present and then any
+ *   excess keys are appended to the url search query after the `?`.
+ *
+ *   Given a template `/path/:verb` and parameter `{verb:'greet', salutation:'Hello'}` results in
+ *   URL `/path/greet?salutation=Hello`.
+ *
+ *   If the parameter value is prefixed with `@` then the value of that parameter is extracted from
+ *   the data object (useful for non-GET operations).
+ *
+ * @param {Object.<Object>=} actions Hash with declaration of custom action that should extend the
+ *   default set of resource actions. The declaration should be created in the following format:
+ *
+ *       {action1: {method:?, params:?, isArray:?},
+ *        action2: {method:?, params:?, isArray:?},
+ *        ...}
+ *
+ *   Where:
+ *
+ *   - `action` – {string} – The name of action. This name becomes the name of the method on your
+ *     resource object.
+ *   - `method` – {string} – HTTP request method. Valid methods are: `GET`, `POST`, `PUT`, `DELETE`,
+ *     and `JSONP`
+ *   - `params` – {object=} – Optional set of pre-bound parameters for this action.
+ *   - isArray – {boolean=} – If true then the returned object for this action is an array, see
+ *     `returns` section.
+ *
+ * @returns {Object} A resource "class" object with methods for the default set of resource actions
+ *   optionally extended with custom `actions`. The default set contains these actions:
+ *
+ *       { 'get':    {method:'GET'},
+ *         'save':   {method:'POST'},
+ *         'query':  {method:'GET', isArray:true},
+ *         'remove': {method:'DELETE'},
+ *         'delete': {method:'DELETE'} };
+ *
+ *   Calling these methods invoke an {@link ng.$http} with the specified http method,
+ *   destination and parameters. When the data is returned from the server then the object is an
+ *   instance of the resource class. The actions `save`, `remove` and `delete` are available on it
+ *   as  methods with the `$` prefix. This allows you to easily perform CRUD operations (create,
+ *   read, update, delete) on server-side data like this:
+ *   <pre>
+        var User = $resource('/user/:userId', {userId:'@id'});
+        var user = User.get({userId:123}, function() {
+          user.abc = true;
+          user.$save();
+        });
+     </pre>
+ *
+ *   It is important to realize that invoking a $resource object method immediately returns an
+ *   empty reference (object or array depending on `isArray`). Once the data is returned from the
+ *   server the existing reference is populated with the actual data. This is a useful trick since
+ *   usually the resource is assigned to a model which is then rendered by the view. Having an empty
+ *   object results in no rendering, once the data arrives from the server then the object is
+ *   populated with the data and the view automatically re-renders itself showing the new data. This
+ *   means that in most case one never has to write a callback function for the action methods.
+ *
+ *   The action methods on the class object or instance object can be invoked with the following
+ *   parameters:
+ *
+ *   - HTTP GET "class" actions: `Resource.action([parameters], [success], [error])`
+ *   - non-GET "class" actions: `Resource.action([parameters], postData, [success], [error])`
+ *   - non-GET instance actions:  `instance.$action([parameters], [success], [error])`
+ *
+ *
+ * @example
+ *
+ * # Credit card resource
+ *
+ * <pre>
+     // Define CreditCard class
+     var CreditCard = $resource('/user/:userId/card/:cardId',
+      {userId:123, cardId:'@id'}, {
+       charge: {method:'POST', params:{charge:true}}
+      });
+
+     // We can retrieve a collection from the server
+     var cards = CreditCard.query(function() {
+       // GET: /user/123/card
+       // server returns: [ {id:456, number:'1234', name:'Smith'} ];
+
+       var card = cards[0];
+       // each item is an instance of CreditCard
+       expect(card instanceof CreditCard).toEqual(true);
+       card.name = "J. Smith";
+       // non GET methods are mapped onto the instances
+       card.$save();
+       // POST: /user/123/card/456 {id:456, number:'1234', name:'J. Smith'}
+       // server returns: {id:456, number:'1234', name: 'J. Smith'};
+
+       // our custom method is mapped as well.
+       card.$charge({amount:9.99});
+       // POST: /user/123/card/456?amount=9.99&charge=true {id:456, number:'1234', name:'J. Smith'}
+     });
+
+     // we can create an instance as well
+     var newCard = new CreditCard({number:'0123'});
+     newCard.name = "Mike Smith";
+     newCard.$save();
+     // POST: /user/123/card {number:'0123', name:'Mike Smith'}
+     // server returns: {id:789, number:'01234', name: 'Mike Smith'};
+     expect(newCard.id).toEqual(789);
+ * </pre>
+ *
+ * The object returned from this function execution is a resource "class" which has "static" method
+ * for each action in the definition.
+ *
+ * Calling these methods invoke `$http` on the `url` template with the given `method` and `params`.
+ * When the data is returned from the server then the object is an instance of the resource type and
+ * all of the non-GET methods are available with `$` prefix. This allows you to easily support CRUD
+ * operations (create, read, update, delete) on server-side data.
+
+   <pre>
+     var User = $resource('/user/:userId', {userId:'@id'});
+     var user = User.get({userId:123}, function() {
+       user.abc = true;
+       user.$save();
+     });
+   </pre>
+ *
+ * It's worth noting that the success callback for `get`, `query` and other method gets passed
+ * in the response that came from the server as well as $http header getter function, so one
+ * could rewrite the above example and get access to http headers as:
+ *
+   <pre>
+     var User = $resource('/user/:userId', {userId:'@id'});
+     User.get({userId:123}, function(u, getResponseHeaders){
+       u.abc = true;
+       u.$save(function(u, putResponseHeaders) {
+         //u => saved user object
+         //putResponseHeaders => $http header getter
+       });
+     });
+   </pre>
+
+ * # Buzz client
+
+   Let's look at what a buzz client created with the `$resource` service looks like:
+    <doc:example>
+      <doc:source jsfiddle="false">
+       <script>
+         function BuzzController($resource) {
+           this.userId = 'googlebuzz';
+           this.Activity = $resource(
+             'https://www.googleapis.com/buzz/v1/activities/:userId/:visibility/:activityId/:comments',
+             {alt:'json', callback:'JSON_CALLBACK'},
+             {get:{method:'JSONP', params:{visibility:'@self'}}, replies: {method:'JSONP', params:{visibility:'@self', comments:'@comments'}}}
+           );
+         }
+
+         BuzzController.prototype = {
+           fetch: function() {
+             this.activities = this.Activity.get({userId:this.userId});
+           },
+           expandReplies: function(activity) {
+             activity.replies = this.Activity.replies({userId:this.userId, activityId:activity.id});
+           }
+         };
+         BuzzController.$inject = ['$resource'];
+       </script>
+
+       <div ng-controller="BuzzController">
+         <input ng-model="userId"/>
+         <button ng-click="fetch()">fetch</button>
+         <hr/>
+         <div ng-repeat="item in activities.data.items">
+           <h1 style="font-size: 15px;">
+             <img src="{{item.actor.thumbnailUrl}}" style="max-height:30px;max-width:30px;"/>
+             <a href="{{item.actor.profileUrl}}">{{item.actor.name}}</a>
+             <a href ng-click="expandReplies(item)" style="float: right;">Expand replies: {{item.links.replies[0].count}}</a>
+           </h1>
+           {{item.object.content | html}}
+           <div ng-repeat="reply in item.replies.data.items" style="margin-left: 20px;">
+             <img src="{{reply.actor.thumbnailUrl}}" style="max-height:30px;max-width:30px;"/>
+             <a href="{{reply.actor.profileUrl}}">{{reply.actor.name}}</a>: {{reply.content | html}}
+           </div>
+         </div>
+       </div>
+      </doc:source>
+      <doc:scenario>
+      </doc:scenario>
+    </doc:example>
+ */
+angular.module('ngResource', ['ng']).
+  factory('$resource', ['$http', '$parse', function($http, $parse) {
+    var DEFAULT_ACTIONS = {
+      'get':    {method:'GET'},
+      'save':   {method:'POST'},
+      'query':  {method:'GET', isArray:true},
+      'remove': {method:'DELETE'},
+      'delete': {method:'DELETE'}
+    };
+    var noop = angular.noop,
+        forEach = angular.forEach,
+        extend = angular.extend,
+        copy = angular.copy,
+        isFunction = angular.isFunction,
+        getter = function(obj, path) {
+          return $parse(path)(obj);
+        };
+
+    /**
+     * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
+     * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
+     * segments:
+     *    segment       = *pchar
+     *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
+     *    pct-encoded   = "%" HEXDIG HEXDIG
+     *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
+     *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
+     *                     / "*" / "+" / "," / ";" / "="
+     */
+    function encodeUriSegment(val) {
+      return encodeUriQuery(val, true).
+        replace(/%26/gi, '&').
+        replace(/%3D/gi, '=').
+        replace(/%2B/gi, '+');
+    }
+
+
+    /**
+     * This method is intended for encoding *key* or *value* parts of query component. We need a custom
+     * method becuase encodeURIComponent is too agressive and encodes stuff that doesn't have to be
+     * encoded per http://tools.ietf.org/html/rfc3986:
+     *    query       = *( pchar / "/" / "?" )
+     *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
+     *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
+     *    pct-encoded   = "%" HEXDIG HEXDIG
+     *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
+     *                     / "*" / "+" / "," / ";" / "="
+     */
+    function encodeUriQuery(val, pctEncodeSpaces) {
+      return encodeURIComponent(val).
+        replace(/%40/gi, '@').
+        replace(/%3A/gi, ':').
+        replace(/%24/g, '$').
+        replace(/%2C/gi, ',').
+        replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));
+    }
+
+    function Route(template, defaults) {
+      this.template = template = template + '#';
+      this.defaults = defaults || {};
+      var urlParams = this.urlParams = {};
+      forEach(template.split(/\W/), function(param){
+        if (param && (new RegExp("(^|[^\\\\]):" + param + "\\W").test(template))) {
+          urlParams[param] = true;
+        }
+      });
+      this.template = template.replace(/\\:/g, ':');
+    }
+
+    Route.prototype = {
+      url: function(params) {
+        var self = this,
+            url = this.template,
+            val,
+            encodedVal;
+
+        params = params || {};
+        forEach(this.urlParams, function(_, urlParam){
+          val = params.hasOwnProperty(urlParam) ? params[urlParam] : self.defaults[urlParam];
+          if (angular.isDefined(val) && val !== null) {
+            encodedVal = encodeUriSegment(val);
+            url = url.replace(new RegExp(":" + urlParam + "(\\W)", "g"), encodedVal + "$1");
+          } else {
+            url = url.replace(new RegExp("(\/?):" + urlParam + "(\\W)", "g"), function(match,
+                leadingSlashes, tail) {
+              if (tail.charAt(0) == '/') {
+                return tail;
+              } else {
+                return leadingSlashes + tail;
+              }
+            });
+          }
+        });
+        url = url.replace(/\/?#$/, '');
+        var query = [];
+        forEach(params, function(value, key){
+          if (!self.urlParams[key]) {
+            query.push(encodeUriQuery(key) + '=' + encodeUriQuery(value));
+          }
+        });
+        query.sort();
+        url = url.replace(/\/*$/, '');
+        return url + (query.length ? '?' + query.join('&') : '');
+      }
+    };
+
+
+    function ResourceFactory(url, paramDefaults, actions) {
+      var route = new Route(url);
+
+      actions = extend({}, DEFAULT_ACTIONS, actions);
+
+      function extractParams(data, actionParams){
+        var ids = {};
+        actionParams = extend({}, paramDefaults, actionParams);
+        forEach(actionParams, function(value, key){
+          ids[key] = value.charAt && value.charAt(0) == '@' ? getter(data, value.substr(1)) : value;
+        });
+        return ids;
+      }
+
+      function Resource(value){
+        copy(value || {}, this);
+      }
+
+      forEach(actions, function(action, name) {
+        action.method = angular.uppercase(action.method);
+        var hasBody = action.method == 'POST' || action.method == 'PUT' || action.method == 'PATCH';
+        Resource[name] = function(a1, a2, a3, a4) {
+          var params = {};
+          var data;
+          var success = noop;
+          var error = null;
+          switch(arguments.length) {
+          case 4:
+            error = a4;
+            success = a3;
+            //fallthrough
+          case 3:
+          case 2:
+            if (isFunction(a2)) {
+              if (isFunction(a1)) {
+                success = a1;
+                error = a2;
+                break;
+              }
+
+              success = a2;
+              error = a3;
+              //fallthrough
+            } else {
+              params = a1;
+              data = a2;
+              success = a3;
+              break;
+            }
+          case 1:
+            if (isFunction(a1)) success = a1;
+            else if (hasBody) data = a1;
+            else params = a1;
+            break;
+          case 0: break;
+          default:
+            throw "Expected between 0-4 arguments [params, data, success, error], got " +
+              arguments.length + " arguments.";
+          }
+
+          var value = this instanceof Resource ? this : (action.isArray ? [] : new Resource(data));
+          $http({
+            method: action.method,
+            url: route.url(extend({}, extractParams(data, action.params || {}), params)),
+            data: data
+          }).then(function(response) {
+              var data = response.data;
+
+              if (data) {
+                if (action.isArray) {
+                  value.length = 0;
+                  forEach(data, function(item) {
+                    value.push(new Resource(item));
+                  });
+                } else {
+                  copy(data, value);
+                }
+              }
+              (success||noop)(value, response.headers);
+            }, error);
+
+          return value;
+        };
+
+
+        Resource.prototype['$' + name] = function(a1, a2, a3) {
+          var params = extractParams(this),
+              success = noop,
+              error;
+
+          switch(arguments.length) {
+          case 3: params = a1; success = a2; error = a3; break;
+          case 2:
+          case 1:
+            if (isFunction(a1)) {
+              success = a1;
+              error = a2;
+            } else {
+              params = a1;
+              success = a2 || noop;
+            }
+          case 0: break;
+          default:
+            throw "Expected between 1-3 arguments [params, success, error], got " +
+              arguments.length + " arguments.";
+          }
+          var data = hasBody ? this : undefined;
+          Resource[name].call(this, params, data, success, error);
+        };
+      });
+
+      Resource.bind = function(additionalParamDefaults){
+        return ResourceFactory(url, extend({}, paramDefaults, additionalParamDefaults), actions);
+      };
+
+      return Resource;
+    }
+
+    return ResourceFactory;
+  }]);
+
+
+})(window, window.angular);