diaspora-vines 0.1.22 → 0.1.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a46173efffc5217b488d5f6c5976884ccc2f708
-  data.tar.gz: aa7dd385af0c647ff67c13c2342dec210f04e131
+  metadata.gz: 33f5f3afd1563cc0deb0d6c01e2e4e106c080c1c
+  data.tar.gz: c9efd2b5249a1bae0c7b778b8c8450f4b77fa508
 SHA512:
-  metadata.gz: 6b07389956b5f47fc57f9b79afa0a6e28c013da900800e526c31247773877681bcc54a4940356370ebfe3fb2c36a0a62c667b25e71c593e4f151b03ef1b25f0f
-  data.tar.gz: 7196743cd8ee5505f72d05b662b10fc691187437e202bb9e8aef9341a338a7d477d299e1d951d1c2d5f0ef75833d2896a165e68e7a5606aaed802c3dd77d1ae4
+  metadata.gz: b28a8475282ff632df35a67467eb2650c38d7e91d8cf0fb952b151ee94e6d3372e298c20f5d459a57626d2cd105b6fd87789a0a7dcee7803b1146a016ab005a7
+  data.tar.gz: e4334b4750a2858ddc01c82be62a9a6d4af7036ca2e212d861d85fbffb280fe3c3c61844653cb693fd2cb65af72ffc077163d04931f0831b07d9bf754afaeff6

data/conf/config.rb

@@ -12,11 +12,9 @@ Vines::Config.configure do
   # `vines init`.
   certs 'conf/certs'
 
-  # Setup a pepper to generate the encrypted password.
-  pepper "065eb8798b181ff0ea2c5c16aee0ff8b70e04e2ee6bd6e08b49da46924223e39127d5335e466207d42bf2a045c12be5f90e92012a4f05f7fc6d9f3c875f4c95b"
-
   host 'diaspora' do
     cross_domain_messages true
+    accept_self_signed false
     storage 'sql'
   end
 
@@ -31,14 +29,14 @@ Vines::Config.configure do
   # much larger than the setting for client-to-server.
   server '0.0.0.0', 5269 do
     max_stanza_size 131072
-    hosts []
+    blacklist []
   end
 
   # Configure the built-in HTTP server that serves static files and responds to
   # XEP-0124 BOSH requests. This allows HTTP clients to connect to
   # the XMPP server.
   http '0.0.0.0', 5280 do
-    bind '/xmpp'
+    bind '/http-bind'
     max_stanza_size 65536
     max_resources_per_account 5
     root 'public'

data/lib/vines.rb

@@ -54,12 +54,6 @@ module Vines
   end
 end
 
-begin
-  # try to initialize diaspora configuration
-  require "#{Dir.pwd}/config/application.rb"
-  require "#{Dir.pwd}/config/load_config.rb"
-rescue LoadError; end
-
 %w[
   active_record
   base64
@@ -72,13 +66,13 @@ rescue LoadError; end
   http/parser
   json
   logger
-  net/ldap
   nokogiri
   openssl
   optparse
   resolv
   set
   socket
+  uri
   yaml
 
   vines/cli
@@ -116,7 +110,6 @@ rescue LoadError; end
   vines/stanza/pubsub/unsubscribe
 
   vines/storage
-  vines/storage/ldap
   vines/storage/local
   vines/storage/sql
   vines/storage/null
@@ -192,12 +185,21 @@ rescue LoadError; end
   vines/stream/server/outbound/final_restart
   vines/stream/server/outbound/final_features
 
-  vines/command/bcrypt
   vines/command/cert
-  vines/command/init
-  vines/command/ldap
   vines/command/restart
-  vines/command/schema
   vines/command/start
   vines/command/stop
 ].each {|f| require f }
+
+# Try loading diaspora configuration
+%w[
+  config/application.rb
+  config/load_config.rb
+  config/initializers/devise.rb
+].each {|c|
+  begin
+    require "#{Dir.pwd}/#{c}"
+  rescue LoadError
+    puts "Was not able to load #{c}! This not a standalone version. You should use it only in a diaspora environment."
+  end
+}

data/lib/vines/cli.rb

@@ -3,7 +3,7 @@ module Vines
   # in the gem. Parses the command line arguments to create a new server
   # directory, and starts and stops the server.
   class CLI
-    COMMANDS = %w[start stop restart init bcrypt cert ldap schema]
+    COMMANDS = %w[start stop restart cert]
 
     def self.start
       self.new.start
@@ -14,36 +14,17 @@ module Vines
     #
     # Returns nothing.
     def start
-      register_storage
       opts = parse(ARGV)
-      check_config(opts)
       command = Command.const_get(opts[:command].capitalize).new
       begin
         command.run(opts)
       rescue SystemExit
         # do nothing
-      rescue Exception => e
-        puts e.message
-        exit(1)
       end
     end
 
     private
 
-    # Try to load various storage backends provided by vines-* gems and register
-    # them with the storage system for the config file to use.
-    #
-    # Returns nothing.
-    def register_storage
-      %w[couchdb mongodb redis sql].each do |backend|
-        begin
-          require 'vines/storage/%s' % backend
-        rescue LoadError
-          # do nothing
-        end
-      end
-    end
-
     # Parse the command line arguments and run the matching sub-command
     # (e.g. init, start, stop, etc).
     #
@@ -110,22 +91,12 @@ module Vines
       options.tap do |opts|
         opts[:args]    = args
         opts[:command] = command
-        opts[:config]  = File.expand_path("#{Dir.pwd}/config/vines.rb") || File.expand_path("conf/config.rb")
+        opts[:config]  = File.expand_path("conf/config.rb")
         opts[:pid]     = File.expand_path(opts[:pid])
         opts[:log]     = File.expand_path(opts[:log])
-      end
-    end
-
-    # Many commands must be run in the context of a vines server directory
-    # created with `vines init`. If the command can't find the server's config
-    # file, print an error message and exit.
-    #
-    # Returns nothing.
-    def check_config(opts)
-      return if %w[bcrypt init].include?(opts[:command])
-      unless File.exists?(opts[:config])
-        puts "No config file found at #{opts[:config]}"
-        exit(1)
+        if defined? AppConfig
+          opts[:config] = "vines/config/diaspora"
+        end
       end
     end
   end

data/lib/vines/command/start.rb

@@ -25,4 +25,4 @@ module Vines
       end
     end
   end
-end
+end

data/lib/vines/config.rb

@@ -21,7 +21,6 @@ module Vines
     end
 
     def initialize(&block)
-      @pepper = "" # no pepper set
       @certs = File.expand_path('conf/certs')
       @vhosts, @ports, @cluster = {}, {}, nil
       @null = Storage::Null.new
@@ -39,19 +38,11 @@ module Vines
       dupes = names.uniq.size != names.size || (@vhosts.keys & names).any?
       raise "one host definition per domain allowed" if dupes
       names.each do |name|
-        if name.eql? "diaspora"
-          @vhosts[domain_name] = Host.new(self, domain_name, &block)
-        else
-          @vhosts[name] = Host.new(self, name, &block)
-        end
+        @vhosts[name] = Host.new(self, name, &block)
       end
     end
 
-    def pepper(pepper=nil)
-      pepper ? @pepper = pepper : @pepper
-    end
-
-    def domain_name
+    def diaspora_domain
       AppConfig.environment.url
         .gsub(/^http(s){0,1}:\/\/|\/$/, '')
         .to_s rescue "localhost"
@@ -78,7 +69,7 @@ module Vines
         unless File.exists?(file)
           File.new(file, 'w') rescue raise "log directory doesn't exists"
         end
-        
+
         if File.exists?(file)
           Vines::Log.set_log_file(file)
         end
@@ -158,10 +149,10 @@ module Vines
     # Returns true if server-to-server connections are allowed with the
     # given domain.
     def s2s?(domain)
-      # NOTE: Disabled whitelisting; It is necessary to allow
-      # anonymous hosts, otherwise everyone has to add all hosts manually
-      # TODO: Create a blacklist in case we have to block a malicious host
-      @ports[:server] # && @ports[:server].hosts.include?(domain.to_s)
+      # Disabled whitelisting to allow anonymous hosts,
+      # otherwise everyone has to add manually all hosts.
+      # Using blacklist in case we have to block a malicious host.
+      @ports[:server] && !@ports[:server].blacklist.include?(domain.to_s)
     end
 
     # Return true if the server is a member of a cluster, serving the same

data/lib/vines/config/diaspora.rb

@@ -0,0 +1,35 @@
+# ############################################################## #
+# Do NOT touch this file you'll find the options in diaspora.yml #
+# ############################################################## #
+
+Vines::Config.configure do
+  log AppConfig.chat.server.log.file.to_s do
+    level AppConfig.chat.server.log.level.to_sym
+  end
+
+  certs AppConfig.chat.server.certs.to_s
+
+  host diaspora_domain do
+    cross_domain_messages AppConfig.chat.server.cross_domain_messages
+    accept_self_signed AppConfig.chat.server.accept_self_signed
+    storage 'sql'
+  end
+
+  client AppConfig.chat.server.c2s.address.to_s, AppConfig.chat.server.c2s.port.to_i do
+    max_stanza_size AppConfig.chat.server.c2s.max_stanza_size.to_i
+    max_resources_per_account AppConfig.chat.server.c2s.max_resources_per_account.to_i
+  end
+
+  server AppConfig.chat.server.s2s.address.to_s, AppConfig.chat.server.s2s.port.to_i do
+    max_stanza_size AppConfig.chat.server.s2s.max_stanza_size.to_i
+    blacklist AppConfig.chat.server.s2s.blacklist.get
+  end
+
+  http AppConfig.chat.server.bosh.address.to_s, AppConfig.chat.server.bosh.port.to_i do
+    bind AppConfig.chat.server.bosh.bind.to_s
+    max_stanza_size AppConfig.chat.server.bosh.max_stanza_size.to_i
+    max_resources_per_account AppConfig.chat.server.bosh.max_resources_per_account.to_i
+    root 'public'
+    vroute ''
+  end
+end

data/lib/vines/config/host.rb

@@ -11,9 +11,10 @@ module Vines
 
       def initialize(config, name, &block)
         @config, @name = config, name.downcase
-        @storage, @ldap = nil, nil
+        @storage = nil
         @cross_domain_messages = false
         @private_storage = false
+        @accept_self_signed = false
         @components, @pubsubs = {}, {}
         validate_domain(@name)
         instance_eval(&block)
@@ -24,15 +25,17 @@ module Vines
         if name
           raise "one storage mechanism per host allowed" if @storage
           @storage = Storage.from_name(name, &block)
-          @storage.ldap = @ldap
         else
           @storage
         end
       end
 
-      def ldap(host='localhost', port=636, &block)
-        @ldap = Storage::Ldap.new(host, port, &block)
-        @storage.ldap = @ldap if @storage
+      def accept_self_signed(enabled)
+        @accept_self_signed = !!enabled
+      end
+
+      def accept_self_signed?
+        @accept_self_signed
       end
 
       def cross_domain_messages(enabled)

data/lib/vines/config/port.rb

@@ -59,16 +59,16 @@ module Vines
 
     class ServerPort < Port
       def initialize(config, host='0.0.0.0', port=5269, &block)
-        @hosts, @stream = [], Vines::Stream::Server
+        @blacklist, @stream = [], Vines::Stream::Server
         super(config, host, port, &block)
       end
 
-      def hosts(*hosts)
-        if hosts.any?
-          @hosts << hosts
-          @hosts.flatten!
+      def blacklist(*blacklist)
+        if blacklist.any?
+          @blacklist << blacklist
+          @blacklist.flatten!
         else
-          @hosts
+          @blacklist
         end
       end
     end

data/lib/vines/stanza/iq/offline.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Ping < Iq
+        include Vines::Log
+
+        NS = NAMESPACES[:disco_info]
+        NODE = NAMESPACES[:offline]
+
+        register "/iq[@id and @type='get']/ns:offline", 'ns' => NODE
+
+        def process
+          log.debug("heelo world::#{to_result.to_yaml}")
+          #return if route_iq || !allowed?
+          #stream.write(to_result)
+          result = to_result.tap do |el|
+            el << el.document.create_element('query') do |query|
+              query.default_namespace = NS
+              query['node'] = NODE
+              items = [
+                [
+                  :jid => 'romeo@montague.net',
+                  :node => '2003-02-27T22:49:17.008Z',
+                  :name => 'mercutio@shakespeare.lit/pda'
+                ],
+                [
+                  :jid => 'romeo@montague.net',
+                  :node => '2003-02-27T22:52:51.270Z',
+                  :name => 'juliet@capulet.com/balcony'
+                ]
+              ]
+              items(query, items)
+            end
+          end
+          stream.write(result)
+        end
+
+        private
+
+        def items(query, *items)
+          items.flatten.each do |item|
+            query << query.document.create_element(
+              'item',
+              'jid' => item[:jid],
+              'node' => item[:node],
+              'name'=> item[:name])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/storage.rb

@@ -4,12 +4,14 @@ module Vines
   class Storage
     include Vines::Log
 
-    attr_accessor :ldap
-
     @@nicks = {}
 
     # Register a nickname that can be used in the config file to specify this
     # storage implementation.
+    #
+    # name - The String name for this storage backend.
+    #
+    # Returns nothing.
     def self.register(name)
       @@nicks[name.to_sym] = self
     end
@@ -25,15 +27,18 @@ module Vines
     # with blocking IO don't need to worry about threading or blocking the
     # EventMachine reactor thread if they wrap their methods with this one.
     #
-    # For example:
-    # def find_user(jid)
-    #   some_blocking_lookup(jid)
-    # end
-    # defer :find_user
+    # Examples
+    #
+    #   def find_user(jid)
+    #     some_blocking_lookup(jid)
+    #   end
+    #   defer :find_user
     #
     # Storage classes that use asynchronous IO (through an EventMachine
     # enabled library like em-http-request or em-redis) don't need any special
     # consideration and must not use this method.
+    #
+    # Returns nothing.
     def self.defer(method)
       old = instance_method(method)
       define_method method do |*args|
@@ -45,40 +50,26 @@ module Vines
       end
     end
 
-    # Wrap an authenticate method with a new method that uses LDAP if it's
-    # enabled in the config file. If LDAP is not enabled, invoke the original
-    # authenticate method as usual. This allows storage classes to implement
-    # their native authentication logic and not worry about handling LDAP.
-    #
-    # For example:
-    # def authenticate(username, password)
-    #   some_user_lookup_by_password(username, password)
-    # end
-    # wrap_ldap :authenticate
-    def self.wrap_ldap(method)
-      old = instance_method(method)
-      define_method method do |*args|
-        ldap? ? authenticate_with_ldap(*args) : old.bind(self).call(*args)
-      end
-    end
-
     # Wrap a method with Fiber yield and resume logic. The method must yield
     # its result to a block. This makes it easier to write asynchronous
-    # implementations of +authenticate+, +find_user+, and +save_user+ that
+    # implementations of `authenticate`, `find_user`, and `save_user` that
     # block and return a result rather than yielding.
     #
-    # For example:
-    # def find_user(jid)
-    #   http = EM::HttpRequest.new(url).get
-    #   http.callback { yield build_user_from_http_response(http) }
-    # end
-    # fiber :find_user
+    # Examples
+    #
+    #   def find_user(jid)
+    #     http = EM::HttpRequest.new(url).get
+    #     http.callback { yield build_user_from_http_response(http) }
+    #   end
+    #   fiber :find_user
     #
-    # Because +find_user+ has been wrapped in Fiber logic, we can call it
+    # Because `find_user` has been wrapped in Fiber logic, we can call it
     # synchronously even though it uses asynchronous EventMachine calls.
     #
-    # user = storage.find_user('alice@wonderland.lit')
-    # puts user.nil?
+    #   user = storage.find_user('alice@wonderland.lit')
+    #   puts user.nil?
+    #
+    # Returns nothing.
     def self.fiber(method)
       old = instance_method(method)
       define_method method do |*args|
@@ -90,114 +81,162 @@ module Vines
       end
     end
 
-    # Return +true+ if users are authenticated against an LDAP directory.
-    def ldap?
-      !!ldap
-    end
-
-    # Validate the username and password pair and return a +Vines::User+ object
-    # on success. Return +nil+ on failure.
+    # Validate the username and password pair.
+    #
+    # username - The String login JID to verify.
+    # password - The String password the user presented to the server.
     #
-    # For example:
-    # user = storage.authenticate('alice@wonderland.lit', 'secr3t')
-    # puts user.nil?
+    # Examples
+    #
+    #   user = storage.authenticate('alice@wonderland.lit', 'secr3t')
+    #   puts user.nil?
     #
     # This default implementation validates the password against a bcrypt hash
     # of the password stored in the database. Sub-classes not using bcrypt
     # passwords must override this method.
+    #
+    # Returns a Vines::User object on success, nil on failure.
     def authenticate(username, password)
       user = find_user(username)
       hash = BCrypt::Password.new(user.password) rescue nil
       (hash && hash == password) ? user : nil
     end
-    wrap_ldap :authenticate
 
-    # Return the +Vines::User+ associated with the JID. Return +nil+ if the user
-    # could not be found. JID may be +nil+, a +String+, or a +Vines::JID+
-    # object. It may be a bare JID or a full JID. Implementations of this method
-    # must convert the JID to a bare JID before searching for the user in the
-    # database.
+    # Find the user in the storage database by their unique JID.
+    #
+    # jid - The String or JID of the user, possibly nil. This may be either a
+    #       bare JID or full JID. Implementations of this method must convert
+    #       the JID to a bare JID before searching for the user in the database.
     #
-    # user = storage.find_user('alice@wonderland.lit')
-    # puts user.nil?
+    # Examples
+    #
+    #   # Bare JID lookup.
+    #   user = storage.find_user('alice@wonderland.lit')
+    #   puts user.nil?
+    #
+    #   # Full JID lookup.
+    #   user = storage.find_user('alice@wonderland.lit/tea')
+    #   puts user.nil?
+    #
+    # Returns the User identified by the JID, nil if not found.
     def find_user(jid)
       raise 'subclass must implement'
     end
 
-    # Persist the +Vines::User+ object to the database and return when the save
-    # is complete.
+    # Persist the user to the database, and return when the save is complete.
+    #
+    # user - The User to persist.
+    #
+    # Examples
+    #
+    #   alice = Vines::User.new(jid: 'alice@wonderland.lit')
+    #   storage.save_user(alice)
+    #   puts 'saved'
     #
-    # alice = Vines::User.new(:jid => 'alice@wonderland.lit')
-    # storage.save_user(alice)
-    # puts 'saved'
+    # Returns nothing.
     def save_user(user)
       raise 'subclass must implement'
     end
 
-    # Return the Nokogiri::XML::Node for the vcard stored for this JID. Return
-    # nil if the vcard could not be found. JID may be +nil+, a +String+, or a
-    # +Vines::JID+ object. It may be a bare JID or a full JID. Implementations
-    # of this method must convert the JID to a bare JID before searching for the
-    # vcard in the database.
+    # Find the user's vcard by their unique JID.
     #
-    # card = storage.find_vcard('alice@wonderland.lit')
-    # puts card.nil?
+    # jid - The String or JID of the user, possibly nil. This may be either a
+    #       bare JID or full JID. Implementations of this method must convert
+    #       the JID to a bare JID before searching for the vcard in the database.
+    #
+    # Examples
+    #
+    #   card = storage.find_vcard('alice@wonderland.lit')
+    #   puts card.nil?
+    #
+    # Returns the vcard's Nokogiri::XML::Node, nil if not found.
     def find_vcard(jid)
       raise 'subclass must implement'
     end
 
-    # Save the vcard to the database and return when the save is complete. JID
-    # may be a +String+ or a +Vines::JID+ object.  It may be a bare JID or a
-    # full JID. Implementations of this method must convert the JID to a bare
-    # JID before saving the vcard. Card is a +Nokogiri::XML::Node+ object.
+    # Save the vcard to the database, and return when the save is complete.
+    #
+    # jid  - The String or JID of the user, possibly nil. This may be either a
+    #        bare JID or full JID. Implementations of this method must convert
+    #        the JID to a bare JID before saving the vcard.
+    # card - The vcard's Nokogiri::XML::Node.
+    #
+    # Examples
+    #
+    #   card = Nokogiri::XML('<vCard>...</vCard>').root
+    #   storage.save_vcard('alice@wonderland.lit', card)
+    #   puts 'saved'
     #
-    # card = Nokogiri::XML('<vCard>...</vCard>').root
-    # storage.save_vcard('alice@wonderland.lit', card)
-    # puts 'saved'
+    # Returns nothing.
     def save_vcard(jid, card)
       raise 'subclass must implement'
     end
 
-    # Return the Nokogiri::XML::Node for the XML fragment stored for this JID.
-    # Return nil if the fragment could not be found. JID may be +nil+, a
-    # +String+, or a +Vines::JID+ object. It may be a bare JID or a full JID.
-    # Implementations of this method must convert the JID to a bare JID before
-    # searching for the fragment in the database.
-    #
-    # Private XML storage uniquely identifies fragments by JID, root element name,
+    # Find the private XML fragment previously stored by the user. Private
+    # XML storage uniquely identifies fragments by JID, root element name,
     # and root element namespace.
     #
-    # root = Nokogiri::XML('<custom xmlns="urn:custom:ns"/>').root
-    # fragment = storage.find_fragment('alice@wonderland.lit', root)
-    # puts fragment.nil?
+    # jid  - The String or JID of the user, possibly nil. This may be either a
+    #        bare JID or full JID. Implementations of this method must convert
+    #        the JID to a bare JID before searching for the fragment in the database.
+    # node - The XML::Node that uniquely identifies the fragment by element
+    #        name and namespace.
+    #
+    # Examples
+    #
+    #   root = Nokogiri::XML('<custom xmlns="urn:custom:ns"/>').root
+    #   fragment = storage.find_fragment('alice@wonderland.lit', root)
+    #   puts fragment.nil?
+    #
+    # Returns the fragment's Nokogiri::XML::Node or nil if not found.
     def find_fragment(jid, node)
       raise 'subclass must implement'
     end
 
-    # Save the XML fragment to the database and return when the save is complete.
-    # JID may be a +String+ or a +Vines::JID+ object.  It may be a bare JID or a
-    # full JID. Implementations of this method must convert the JID to a bare
-    # JID before saving the fragment. Fragment is a +Nokogiri::XML::Node+ object.
+    # Save the XML fragment to the database, and return when the save is complete.
+    #
+    # jid      - The String or JID of the user, possibly nil. This may be
+    #            either a bare JID or full JID. Implementations of this method
+    #            must convert the JID to a bare JID before searching for the
+    #            fragment.
+    # fragment - The XML::Node to save.
+    #
+    # Examples
     #
-    # fragment = Nokogiri::XML('<custom xmlns="urn:custom:ns">some data</custom>').root
-    # storage.save_fragment('alice@wonderland.lit', fragment)
-    # puts 'saved'
+    #   fragment = Nokogiri::XML('<custom xmlns="urn:custom:ns">some data</custom>').root
+    #   storage.save_fragment('alice@wonderland.lit', fragment)
+    #   puts 'saved'
+    #
+    # Returns nothing.
     def save_fragment(jid, fragment)
       raise 'subclass must implement'
     end
 
     private
 
-    # Return true if any of the arguments are nil or empty strings.
-    # For example:
-    # username, password = 'alice@wonderland.lit', ''
-    # empty?(username, password) #=> true
+    # Determine if any of the arguments are nil or empty strings.
+    #
+    # Examples
+    #
+    #   username, password = 'alice@wonderland.lit', ''
+    #   empty?(username, password) #=> true
+    #
+    # Returns true if any of the arguments are nil or empty strings.
     def empty?(*args)
       args.flatten.any? {|arg| (arg || '').strip.empty? }
     end
 
-    # Return a +proc+ suitable for running on the +EM.defer+ thread pool that traps
-    # and logs any errors thrown by the provided block.
+    # Create a proc suitable for running on the EM.defer thread pool, that
+    # traps and logs any errors thrown by the provided block.
+    #
+    # block - The block to wrap in error handling.
+    #
+    # Examples
+    #
+    #   op = operation { do_something_on_thread_pool() }
+    #   EM.defer(op)
+    #
+    # Returns a Proc.
     def operation
       proc do
         begin
@@ -208,32 +247,5 @@ module Vines
         end
       end
     end
-
-    # Return a +Vines::User+ object if we are able to bind to the LDAP server
-    # using the username and password. Return +nil+ if authentication failed. If
-    # authentication succeeds, but the user is not yet stored in our database,
-    # save the user to the database.
-    def authenticate_with_ldap(username, password, &block)
-      op = operation { ldap.authenticate(username, password) }
-      cb = proc {|user| save_ldap_user(user, &block) }
-      EM.defer(op, cb)
-    end
-    fiber :authenticate_with_ldap
-
-    # Save missing users to the storage database after they're authenticated with
-    # LDAP. This allows admins to define users once in LDAP and have them sync
-    # to the chat database the first time they successfully sign in.
-    def save_ldap_user(user, &block)
-      Fiber.new do
-        if user.nil?
-          block.call
-        elsif found = find_user(user.jid)
-          block.call(found)
-        else
-          save_user(user)
-          block.call(user)
-        end
-      end.resume
-    end
   end
 end