anchor.diff:                  Invalid(error_message, 404, "Illegal action")
   
               | "resource"::resource_path_parts -> // Someone requests a resource
  -                try_forward_resource node resource_path_parts meth body response inter
  +                let res = try_forward_resource node resource_path_parts meth body response inter
  +                // Handle sending of backups
  +                match res with
  +                | Valid(node', state') ->
  +                    // Serialize the updated state
  +                    let state_msg = inter.serialize state'
  +
  +                    // Send it to the node closest to itself
  +                    send_backup_state node state_msg
  +
  +                    res
  +                | _ -> res
   
               | _ ->
                   let error_message = sprintf "Not related to this: %s" path
  
positive.code:     | Error(msg, status, reason) ->
          Invalid(msg, status, reason)
  
  // Sends a backup state to the nodes that are watching this node
  let send_backup_state (node: Node) (state_msg: string) =
      let folder k v acc =
          if k < node.guid && distance k node.guid < distance acc node.guid then
              k
          else
              acc
      let minleaf = Map.foldBack folder node.leaves node.guid
      if minleaf = node.guid then // No smaller leaves
          // Send it to the highest leaf
          printfn "PASTRY: No other leaves, backup delayed..."
      else
          let address =
              match Map.tryFind minleaf node.leaves with
              | Some(addr) ->
                  addr
              | None ->
                  failwith "ASSERTION FAILED: Smallest key not found in leaves... WTF!"
          match send_message address Backup state_msg minleaf with
          | None ->
              printfn "PASTRY: No reply for backup: Handle node failure?"
          | Some(resp, status) ->
              ()
  
  // Makes the given pastry node start listening...
  let start_listening<'a> (node: Node) (inter_arg: PastryInterface<'a>) =
      printfn "Initializing..."
  
negative.code:         // NOTE: Only invalid requests are automatically replied
          match result with
          | Valid(updated_node, updated_state) ->
              listen updated_node { inter with state = updated_state; }
          | Invalid(error_message, status, reason) ->
              error error_message
  