vines-services 0.1.0

data/lib/vines/services/config.rb

@@ -0,0 +1,105 @@
+# encoding: UTF-8
+
+module Vines
+  module Services
+    # A Config object is passed to the xmpp connections to give them access
+    # to server configuration information like component subdomain host names,
+    # storage systems, etc. This class provides the DSL methods used in the
+    # conf/config.rb file.
+    class Config
+      LOG_LEVELS = %w[debug info warn error fatal].freeze
+
+      attr_reader :vhosts
+
+      @@instance = nil
+      def self.configure(&block)
+        @@instance = self.new(&block)
+      end
+
+      def self.instance
+        @@instance
+      end
+
+      def initialize(&block)
+        @vhosts = {}
+        instance_eval(&block)
+        raise "must define at least one virtual host" if @vhosts.empty?
+      end
+
+      def host(*names, &block)
+        names = names.flatten.map {|name| name.downcase }
+        dupes = names.uniq.size != names.size || (@vhosts.keys & names).any?
+        raise "one host definition per domain allowed" if dupes
+        names.each do |name|
+          @vhosts[name] = Host.new(name, &block)
+        end
+      end
+
+      def log(level)
+        const = Logger.const_get(level.to_s.upcase) rescue nil
+        unless LOG_LEVELS.include?(level.to_s) && const
+          raise "log level must be one of: #{LOG_LEVELS.join(', ')}"
+        end
+        log = Class.new.extend(Vines::Log).log
+        log.progname = 'vines-service'
+        log.level = const
+        Blather.logger.level = const
+      end
+
+      def hosts
+        @vhosts.values
+      end
+
+      class Host
+        attr_reader :name
+
+        def initialize(name, &block)
+          @name, @storage, @uploads, @upstream = name, nil, nil, []
+          instance_eval(&block)
+          raise "storage required for #{@name}" unless @storage
+          raise "upstream connection required for #{@name}" if @upstream.empty?
+          unless @uploads
+            @uploads = File.expand_path('data/upload')
+            FileUtils.mkdir_p(@uploads)
+          end
+        end
+
+        def uploads(dir=nil)
+          return @uploads unless dir
+          @uploads = File.expand_path(dir)
+          begin
+            FileUtils.mkdir_p(@uploads)
+          rescue
+            raise "can't create #{@uploads}"
+          end
+        end
+
+        def storage(name=nil, &block)
+          if name
+            raise "one storage mechanism per host allowed" if @storage
+            @storage = Storage.from_name(name, &block)
+          else
+            @storage
+          end
+        end
+
+        def upstream(host, port, password)
+          raise 'host, port, and password required for upstream connections' unless
+            host && port && password
+          @upstream << {host: host, port: port, password: password}
+        end
+
+        def start
+          @upstream.each do |info|
+            stream = Vines::Services::Connection.new(
+              host:     info[:host],
+              port:     info[:port],
+              password: info[:password],
+              vhost:    self)
+            stream.start
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/services/connection.rb

@@ -0,0 +1,120 @@
+# encoding: UTF-8
+
+module Vines
+  module Services
+    # Connects the component process to the chat server and provides the protocol
+    # used by the web user interface and the agents.
+    class Connection
+      include Vines::Log
+
+      @@controllers = []
+      def self.register(*args, klass)
+        @@controllers << [args, klass]
+      end
+
+      def initialize(options)
+        host, port, password, @vhost = *options.values_at(:host, :port, :password, :vhost)
+        @stream = Blather::Client.setup(@vhost.name, password, host, port)
+        @throttle = Throttle.new(@stream)
+        @queues = {}
+
+        @stream.register_handler(:disconnected) do
+          log.info("Stream disconnected, reconnecting . . .")
+          EM::Timer.new(10) do
+            self.class.new(options).start
+          end
+          true # prevent EM.stop
+        end
+
+        @stream.register_handler(:ready) do
+          log.info("Connected #{@stream.jid} component to #{host}:#{port}")
+          Fiber.new do
+            broadcast_presence
+          end.resume
+        end
+
+        @stream.register_handler(:iq, '/iq[@type="get"]/ns:query', :ns => 'jabber:iq:version') do |node|
+          if node.to == @stream.jid
+            iq = Blather::Stanza::Iq::Query.new(:result)
+            iq.id, iq.to = node.id, node.from
+            iq.query.add_child("<name>Vines Services</name>")
+            iq.query.add_child("<version>#{VERSION}</version>")
+            @stream.write(iq)
+          end
+        end
+
+        @@controllers.each do |args, klass|
+          @stream.register_handler(*args) do |node|
+            jid = node.from.to_s
+            start = !@queues.key?(jid)
+            queue = (@queues[jid] ||= EM::Queue.new)
+            queue.push([node, klass])
+            process_node_queue(jid) if start
+          end
+        end
+      end
+
+      def start
+        @stream.run
+      end
+
+      private
+
+      # Send initial presence from each service JID to its users when the
+      # component starts.
+      def broadcast_presence
+        services = CouchModels::Service.find_all
+        users = services.map {|service| service.users }.flatten.uniq
+        nodes = users.map {|jid| available(@stream.jid, jid) }
+        nodes << services.map do |service|
+          service.users.map {|jid| available(service.jid, jid) }
+        end
+        nodes.flatten!
+        @throttle.async_send(nodes)
+      end
+
+      def available(from, to)
+        Blather::Stanza::Presence::Status.new.tap do |node|
+          node.from = from
+          node.to = to
+        end
+      end
+
+      # We must process or deliver stanzas in the order they are received, so
+      # we create a node queue for each sending JID and process it in this loop.
+      #
+      # The process loop continues until the queue is empty for this JID, then
+      # the queue is deleted. JID's come and go frequently, without notifying the
+      # component, so we must delete their queue as soon as it's empty to avoid
+      # maintaining a growing list of queues for JID's we will never see again.
+      #
+      # Each node is wrapped its own Fiber so it can be paused and resumed
+      # during asynchronous IO.
+      def process_node_queue(jid)
+        if @queues[jid].empty?
+          @queues.delete(jid)
+        else
+          @queues[jid].pop do |pair|
+            Fiber.new do
+              process_node(*pair)
+              process_node_queue(jid)
+            end.resume
+          end
+        end
+      end
+
+      # Create a new controller instance to process the node.
+      def process_node(node, klass)
+        begin
+          klass.new(node, @stream, @vhost).process
+        rescue Forbidden
+          log.warn("Authorization failed for #{node.from}:\n#{node}")
+          @stream.write(Blather::StanzaError.new(node, 'forbidden', :auth).to_node)
+        rescue Exception => e
+          log.error("Error processing node: #{e.message}")
+          @stream.write(Blather::StanzaError.new(node, 'internal-server-error', :cancel).to_node)
+        end
+      end
+    end
+  end
+end

data/lib/vines/services/controller/attributes_controller.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+module Vines
+  module Services
+    module Controller
+      class AttributesController < BaseController
+        register :iq, "/iq[@type='get' or @type='set']/ns:query",
+          'ns' => 'http://getvines.com/protocol/systems/attributes'
+
+        private
+
+        def get
+          forbidden! unless current_user.manage_services?
+          send_result(rows: System.find_attributes)
+        end
+      end
+    end
+  end
+end

data/lib/vines/services/controller/base_controller.rb

@@ -0,0 +1,99 @@
+# encoding: UTF-8
+
+module Vines
+  module Services
+    module Controller
+      class BaseController
+        include Vines::Log
+        include CouchModels
+        include Nokogiri::XML
+
+        def self.register(*args)
+          Connection.register(*args, self)
+        end
+
+        attr_reader :storage, :node, :stream, :uploads
+
+        def initialize(node, stream, vhost)
+          @node, @stream, @storage = node, stream, vhost.storage
+          @uploads = vhost.uploads
+          @current_user = nil
+        end
+
+        def process
+          # must be addressed to component, not a service
+          return unless to_component?
+          if node.get?
+            get
+          elsif node.set? && node.elements.first['action'] == 'delete'
+            delete
+          elsif node.set?
+            save
+          end
+        rescue Forbidden
+          raise
+        rescue
+          send_error('not-acceptable')
+        end
+
+        private
+
+        def get
+          send_error('feature-not-implemented')
+        end
+
+        def save
+          send_error('feature-not-implemented')
+        end
+
+        def delete
+          send_error('feature-not-implemented')
+        end
+
+        def send_result(obj=nil)
+          iq = Blather::Stanza::Iq::Query.new(:result).tap do |result|
+            result.id, result.to, result.from = node.id, node.from, node.to
+            result.query.content = obj.to_json if obj
+            result.query.namespace = node.elements.first.namespace.href
+          end
+          stream.write(iq)
+        end
+
+        def send_error(condition, obj=nil)
+          err = Blather::StanzaError.new(node, condition, :modify).tap do |error|
+            error.extras << Blather::XMPPNode.new('vines-error').tap do |verr|
+              verr.namespace = 'http://getvines.com/error'
+              verr.content = obj.to_json
+            end if obj
+          end
+          stream.write(err.to_node)
+        end
+
+        def send_doc(doc)
+          if doc
+            send_result(doc.to_result)
+          else
+            send_error('item-not-found')
+          end
+        end
+
+        # Return true if the stanza is addressed to the component's JID rather
+        # than to a service JID.
+        def to_component?
+          node.to == stream.jid
+        end
+
+        def forbidden!
+          raise Forbidden
+        end
+
+        # Return the User object for the user that sent this stanza. Useful for
+        # permission authorization checks before performing server actions.
+        def current_user
+          jid = node.from.stripped.to_s.downcase
+          @current_user ||= User.find_by_jid(jid)
+        end
+      end
+    end
+  end
+end

data/lib/vines/services/controller/disco_info_controller.rb

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+
+module Vines
+  module Services
+    module Controller
+      class DiscoInfoController < BaseController
+        register :disco_info, :get?
+
+        def process
+          reply = (node.to == stream.jid) ? component : service
+          stream.write(reply) if reply
+        end
+
+        private
+
+        # Return the discovery reply node for a query addressed to the
+        # component JID itself (e.g. vines.wonderland.lit), rather than to a
+        # service JID. Advertise the http://getvines.com/protocol feature
+        # so agents can discover the component JID with which to communicate.
+        def component
+          disco_node.tap do |disco|
+            disco.identities = {
+              name: 'Vines Services',
+              type: 'bot',
+              category: 'component'
+            }
+            disco.features = %w[
+              http://jabber.org/protocol/bytestreams
+              http://jabber.org/protocol/disco#info
+              http://jabber.org/protocol/si
+              http://jabber.org/protocol/si/profile/file-transfer
+              http://jabber.org/protocol/xhtml-im
+              http://getvines.com/protocol
+              jabber:iq:version
+            ]
+          end
+        end
+
+        # Return the discovery reply node for a query addressed to a service
+        # JID (e.g. web_servers@vines.wonderland.lit). Ignore, rather than send
+        # an error, for queries to service JID's that don't exist or to which
+        # the user doesn't have access.
+        def service
+          found = Service.find_by_jid(node.to.to_s)
+          return unless found && found.users.include?(node.from.stripped.to_s)
+          disco_node.tap do |disco|
+            disco.features = %w[http://jabber.org/protocol/xhtml-im]
+          end
+        end
+
+        def disco_node
+          Blather::Stanza::DiscoInfo.new(:result).tap do |disco|
+            disco.id = node.id
+            disco.to = node.from
+            disco.from = node.to
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/services/controller/labels_controller.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+module Vines
+  module Services
+    module Controller
+      class LabelsController < BaseController
+        register :iq, "/iq[@type='get' or @type='set']/ns:query",
+          'ns' => 'http://getvines.com/protocol/files/labels'
+
+        def get
+          forbidden! unless current_user.manage_files?
+          send_result(rows: Upload.find_labels)
+        end
+      end
+    end
+  end
+end

data/lib/vines/services/controller/members_controller.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+
+module Vines
+  module Services
+    module Controller
+      class MembersController < BaseController
+        register :iq, "/iq[@type='get' or @type='set']/ns:query",
+          'ns' => 'http://getvines.com/protocol/services/members'
+
+        private
+
+        def get
+          forbidden! unless current_user.manage_services?
+          if id = node.elements.first['id']
+            rows = Service.find(id).members rescue []
+            send_result(rows: rows)
+          else
+            find_members_by_vql
+          end
+        end
+
+        # Compile the VQL syntax into a SQL query to find matching member
+        # systems. Return a list of members or the parser error so the user
+        # can debug their query syntax.
+        def find_members_by_vql
+          begin
+            code = node.elements.first.content
+            sql, params = VQL::Compiler.new.to_sql(code)
+            query(sql, params)
+          rescue Exception => e
+            send_result(ok: false, error: e.message)
+          end
+        end
+
+        def query(sql, params)
+          storage.query(sql, params) do |rows|
+            members = rows.map {|row| {name: row[0], os: row[1]} }
+            send_result(ok: true, rows: members)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/services/controller/messages_controller.rb

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+
+module Vines
+  module Services
+    module Controller
+      # Broadcast messages from a user to a group of systems (a.k.a. a service).
+      # Responses from the agents are routed back through the component so the
+      # user appears to be talking to just the service's JID, not each and every
+      # agent that belongs to the service.
+      class MessagesController < BaseController
+        register :message, :chat?, :body
+
+        NS = 'http://getvines.com/protocol'.freeze
+
+        def process
+          current_user.system? ? forward_to_user : forward_to_service
+        end
+
+        private
+
+        # Forward the agent's response message to the user that sent it the
+        # command.
+        def forward_to_user
+          jid = node.xpath('/message/ns:jid', 'ns' => NS).first
+          return unless jid
+          jid.remove
+          node.from = node.to
+          node.to = jid.content
+          stream.write(node)
+        end
+
+        # Forward the user's message to the members of the service. Tag the
+        # message with a jid element, identifying the user executing the command
+        # like: <jid xmlns="http://getvines.com/protocol">alice@wonderland.lit/tea</jid>
+        # When the agent receives a message from one of its services, it checks
+        # this jid element for the user permissions with which to run the command.
+        #
+        # Ignore the message, rather than send an error, if the user lacks
+        # privilege to access the service to avoid directory harvesting.
+        def forward_to_service
+          service = Service.find_by_jid(node.to.stripped)
+          if service && service.user?(node.from.stripped)
+            service.members.each do |member|
+              to = Blather::JID.new(member['name'], node.from.domain)
+              stream.write(create_message(to))
+            end
+          else
+            log.warn("#{node.from} denied access to #{node.to}")
+          end
+        end
+
+        # Copy the message's content into a new message destined for the given
+        # agent JID. Identify this command/response exchange with the message's
+        # thread value. Tag the message with a jid element, identifying the
+        # original user that sent the command.
+        def create_message(to)
+          Blather::Stanza::Message.new(to, node.body).tap do |msg|
+            msg.thread = node.thread || Kit.uuid
+            msg.from = node.to
+            msg << msg.document.create_element('jid', node.from, xmlns: NS)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/services/controller/probes_controller.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+
+module Vines
+  module Services
+    module Controller
+      # Reply to presence probes if the user has privilege to access the
+      # requested service JID. Reply to all probes to the component itself.
+      class ProbesController < BaseController
+        register :presence, :probe?
+
+        def process
+          from, to = node.from.stripped, node.to.stripped
+          if approved?
+            stream.write(available(to, from))
+          else
+            stream.write(unsubscribed(to, from))
+          end
+        end
+
+        private
+
+        def approved?
+          return true if to_component?
+          found = Service.find_by_jid(node.to)
+          found && found.user?(node.from.stripped)
+        end
+
+        def available(from, to)
+          Blather::Stanza::Presence::Status.new.tap do |stanza|
+            stanza.from = from
+            stanza.to = to
+          end
+        end
+
+        def unsubscribed(from, to)
+          Blather::Stanza::Presence::Subscription.new.tap do |stanza|
+            stanza.type = :unsubscribed
+            stanza.from = from
+            stanza.to = to
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/services/controller/services_controller.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+
+module Vines
+  module Services
+    module Controller
+      class ServicesController < BaseController
+        register :iq, "/iq[@type='get' or @type='set']/ns:query",
+          'ns' => 'http://getvines.com/protocol/services'
+
+        private
+
+        def get
+          forbidden! unless current_user.manage_services?
+
+          if id = node.elements.first['id']
+            send_doc(Service.find(id))
+          elsif name = node.elements.first['name']
+            send_doc(Service.find_by_name(name))
+          else
+            rows = Service.find_all.map do |doc|
+              {id: doc.id, name: doc.name, size: doc.size}
+            end
+            send_result(rows: rows)
+          end
+        end
+
+        def save
+          forbidden! unless current_user.manage_services?
+
+          obj = JSON.parse(node.elements.first.content)
+          raise 'name required' unless obj['name']
+          obj['jid'] = to_jid(obj['name'])
+          obj['users'] = validate_users(obj['users'])
+
+          begin
+            compiled = VQL::Compiler.new.to_js(obj['code'])
+          rescue Exception => e
+            send_error('not-acceptable', {error: e.message})
+            return
+          end
+
+          service = Service.find(obj['id']) || Service.new
+          members = service.members
+          if service.update_attributes(obj)
+            send_result(service.to_result)
+            members << Service.find(service.id).members
+            System.notify_members(stream, node.from, members.flatten.uniq)
+          else
+            send_error('not-acceptable')
+          end
+        end
+
+        # Ensure the JID's that are given access to this service actually exist
+        # and are not system accounts. System users may never have access to
+        # services. Return the list of JID's that pass validation.
+        def validate_users(jids)
+          return [] unless jids
+          users = User.by_jid.keys(jids)
+          users.map {|u| u.system? ? nil : u.jid }.compact
+        end
+
+        # Create a JID for the service from its given name so we can address
+        # stanzas to the service.
+        def to_jid(name)
+          Blather::JID.new(CGI.escape(name), stream.jid.domain).to_s.downcase
+        end
+
+        def delete
+          forbidden! unless current_user.manage_services?
+
+          if service = Service.find(node.elements.first['id'])
+            service.destroy
+            send_result
+          else
+            send_error('item-not-found')
+          end
+        end
+      end
+    end
+  end
+end