connfu-client 0.1

data/lib/connfu/cli/generator.rb

@@ -0,0 +1,71 @@
+module Connfu
+	##
+	# This module helps a client to manage connFu applications
+  module Cli
+    module Generator
+      
+      APPLICATION_TEMPLATE=<<END
+
+require 'connfu'
+
+##
+# This application is an example of how to create a connFu application
+
+token = "YOUR-VALID-CONNFU-TOKEN"
+
+Connfu.logger = STDOUT
+Connfu.log_level = Logger::DEBUG
+
+Connfu.application(token) {
+
+    listen(:voice) do |conference|
+        conference.on(:join) do |call|
+                puts "New inbound call from \#{call[:from]} on number \#{call[:to]}"
+            end
+
+            conference.on(:leave) do |call|
+                puts "\#{call[:from]} has left the conference \#{call[:channel_name]}"
+            end
+
+            conference.on(:new_topic) do |topic|
+                puts "New topic in the conference \#{topic[:channel_name]}: \#{topic[:content]}"
+            end
+      end
+
+      listen(:twitter) do |twitter|
+            twitter.on(:new) do |tweet|
+                puts "\#{tweet[:channel_name]} just posted a new tweet in the conference room: \#{tweet.content}"
+            end
+      end
+
+      listen(:sms) do |sms|
+            sms.on(:new) do |message|
+                puts "New inbound sms from \#{message[:from]}: \#{message[:content]}"
+            end
+      end
+
+}
+
+END
+      
+      class << self
+        ##
+        #
+        # ==== Parameters
+        # * **name** application name
+        # * **channels** channels the application should listen to
+        # * **file_name** main file that will hold the application logic
+        #
+        # ==== Return
+        def run(name, channels = nil, file_name = "application.rb")
+          Dir.mkdir(name)
+            Dir.chdir(name) do
+            File.open(file_name, 'w') do |f|
+              f.write(APPLICATION_TEMPLATE)
+            end
+          end
+        end # end:run
+      end # end class level
+    end # end module Generator
+  end # end module Cli
+end

data/lib/connfu/connfu_logger.rb

@@ -0,0 +1,88 @@
+require 'logger'
+
+module Connfu
+  ##
+  # This module defines a mixin to be used in any class that needs to log messages.
+  #
+  module ConnfuLogger
+
+    ##
+    # Nice way to include the Module methods when including it in a class/module
+    #
+    # ==== Parameters
+    # * +base+ class that includes the mixin
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    ##
+    # This internal module acts as a wrapper to include the class/module level methods
+    module ClassMethods
+
+      ##
+      # logger setter
+      #
+      # ==== Parameters
+      # * +value+ should be:
+      #   * a valid IO object (STDOUT, string representing a valid filename, File object)
+      #   * a ::Logger instance
+      #
+      # ==== Return
+      # new ::Logger object created
+      def logger=(value)
+        # _logger must be static var and not class var to be shared between objects/classes
+        if value.is_a?(String) or value.is_a?(IO)
+          @@_logger = Logger.new(value)
+        else
+          @@_logger = value
+        end
+      end
+
+      ##
+      # logger getter
+      #
+      # ==== Return
+      # ::Logger object
+      def logger
+        @@_logger ||= create_logger
+      end
+
+      ##
+      # Change logger level
+      #
+      # ==== Parameters
+      # * +level+ valid Logger level constant (::Logger::DEBUG, etc)
+      def log_level=(level)
+        logger.level = level
+      end
+
+      ##
+      # Creates a new Logger object and defines the level and format
+      #
+      # ==== Parameters
+      # * +output+ valid IO object
+      # ==== Return
+      # Logger object
+      def create_logger(output = nil)
+        output.nil? and output = STDOUT
+        logger = Logger.new(output)
+        logger.level = Logger::ERROR
+        #logger.formatter = proc { |severity, datetime, progname, msg|
+        #  "#{severity} on #{datetime} at #{progname}: #{msg}\n"
+        #}
+        logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+        logger
+      end
+    end
+
+    ##
+    # Instance method that wraps the class method
+    # 
+    # ==== Return
+    # * see ClassMethods.logger
+    def logger
+      self.class.logger
+    end
+
+  end
+end

data/lib/connfu/connfu_message_formatter.rb

@@ -0,0 +1,134 @@
+require 'active_support'
+require 'connfu/connfu_logger'
+require 'connfu/message'
+require 'uri'
+
+module Connfu
+
+  ##
+  # This class is in charge of formatting the incoming messages
+  # It's used by any connFu listener to format a raw message got from the streaming API to a
+  # Connfu::Message instance
+  #
+  class ConnfuMessageFormatter
+    include Connfu::ConnfuLogger # application logger
+
+    class << self
+
+      ##
+      # Convert an inbound twitter/RSS event to a Message instance.
+      #
+      # ==== Parameters
+      #
+      # * +message+ raw JSON decoded message
+      # ==== Return
+      # Array of Connfu::Message instances
+      def format_message(message)
+        message.is_a?(String) and message = ActiveSupport::JSON.decode(message)
+        values = []
+
+        # internal method that process the message
+        fetch_values = lambda { |msg|
+          begin
+            if msg.is_a?(Hash)
+              sender = msg["actor"]["id"]
+              recipients = nil
+              user_mentions = msg["object"]["entities"]["user_mentions"]
+              logger.debug(user_mentions)
+              if user_mentions.is_a?(Array) && user_mentions.length > 0
+                recipients = []
+                user_mentions.each { |recipient|
+                  recipients << recipient
+                }
+                if recipients.length.eql?(1)
+                  recipients = recipients[0]
+                end
+              end
+              channel_info = msg["backchat"]["bare_uri"].split(":")
+              logger.debug(channel_info)
+              params = {
+                  :id => msg["object"]["id"],
+                  :content => msg["object"]["content"],
+                  :message_type => "new",
+                  :channel_type => channel_info[0],
+                  :channel_name => channel_info[1][2..-2],
+                  :from => sender,
+                  :to => recipients
+              }
+              params
+            else
+              logger.error("Invalid message format: #{msg}")
+              nil
+            end
+          rescue => ex
+            logger.error("Unable to fetch values from message #{msg}. Caught exception #{ex}")
+            nil
+          end
+        }
+
+        if message.is_a?(Array)
+          message.each { |msg|
+            params = fetch_values.call(msg)
+            # include the message if valid params
+            params.nil? or values << Connfu::Message.new(params)
+          }
+        else
+          params = fetch_values.call(message)
+          # include the message if valid params
+          params.nil? or values << Connfu::Message.new(params)
+        end
+        values
+      end
+
+      ##
+      # Convert the inbound voice/sms event to a Message instance
+      # ==== Parameters
+      # * +message+ raw JSON decoded message
+      #
+      # ==== Return
+      # * Array of one Connfu::Message instance
+      # * Empty array if the message is invalid
+      def format_voice_sms(message)
+        if message.is_a?(Array) and message.length.eql?(2)
+          if Connfu::Message.is_voice?(message[0])
+            logger.debug("Format the new voice message")
+            conference_id = URI.parse(message[1]["conferenceId"]).host
+            params = {
+                :id => 1234,
+                :content => message[1]["newTopic"],
+                :from => message[1]["from"],
+                :to => message[1]["to"],
+                :message_type => message[0],
+                :channel_type => "voice",
+                :channel_name => conference_id
+            }
+            logger.debug(params)
+
+            [Connfu::Message.new(params)]
+          elsif Connfu::Message.is_sms?(message[0])
+            logger.debug("Format the new sms message")
+            params = {
+                :id => 1234,
+                :content => message[1]["message"],
+                :from => message[1]["from"],
+                :to => message[1]["to"],
+                :message_type => "new",
+                :channel_type => "sms",
+                :channel_name => message[1]["appId"]
+            }
+            [Connfu::Message.new(params)]
+          else
+            logger.error("Unexpected message type")
+            logger.error(message)
+            []
+          end
+        else
+          logger.error("Unexpected message format")
+          logger.error(message)
+          []
+        end
+      end
+    end
+
+  end
+end

data/lib/connfu/connfu_stream.rb

@@ -0,0 +1,182 @@
+require 'active_support'
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'thread'
+require 'connfu/connfu_logger'
+require 'connfu/message'
+require 'connfu/connfu_message_formatter'
+
+module Connfu
+
+  ##
+  # Open an HTTP connection to connFu and start listening to any incoming event
+  # This is the entry point to execute any proc in a connFu application
+  # based on external events.
+  class ConnfuStream
+    include Connfu::ConnfuLogger # application logger
+
+    ##
+    # ConnfuStream initializer.
+    # ==== Parameters
+    #
+    # * +app_stream+ valid HTTP stream url to connect and listen events
+    # * +api_key+ valid Token to get access to a Connfu Stream
+    # * +uri+ HTTP endpoint to open the connection
+    def initialize(app_stream, api_key, uri)
+
+      @app_stream = app_stream
+      @api_key = api_key
+
+      _uri = URI.parse(uri)
+      @port = _uri.port
+      @host = _uri.host
+      @path = _uri.path.concat(app_stream)
+      @scheme = _uri.scheme
+
+      @formatter = Connfu::ConnfuMessageFormatter
+    end
+
+    ##
+    # Open a HTTP connection to connFu and start listening new events
+    def start_listening
+
+      begin
+        # http client instantiation and configuration
+        http_client = Net::HTTP.new(@host, @port)
+        logger.debug("#{self.class} opening connection to  #{@host}:#{@port}")
+        http_client.use_ssl = @scheme.eql?("https")
+        if @scheme.eql?("https")
+          http_client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+
+        logger.debug("#{self.class} start listening to stream #{@path}")
+
+        http_client.read_timeout = 60*6 # double the timeout connFu is configured
+
+        # open connection
+        http_client.start do |http|
+          req = Net::HTTP::Get.new(
+              @path,
+              headers)
+
+          # send GET request
+          http.request(req) do |res|
+            logger.debug "#{self.class} Request to the endpoint...."
+            # read chunk data
+            logger.debug "#{self.class} Waiting for a new event...."
+            res.read_body do |chunk|
+              unless chunk.chomp.strip.empty?
+                # format data retrieved
+                events = handle_data(chunk)
+                # Insert message(s) in the queue
+                events.nil? or message(events)
+              else
+                logger.debug "#{self.class} got an empty data"
+              end
+              logger.debug "#{self.class} Waiting for a new event...."
+            end
+          end
+        end
+      rescue Exception => ex
+        logger.error "[#{Time.now} | #{ex.class}] #{ex.message}\n#{ex.backtrace.join("\n")}"
+        # loop again
+        start_listening
+      end
+    end
+
+    ##
+    # This method should be called by the class that instantiates the ConnfuStream to fetch inbound events.
+    # It stops the execution waiting for an inbound event.
+    #
+    # ==== Return
+    # Connfu::Message instance
+    def get
+      queue.pop
+    end
+
+    private
+
+    ##
+    # Internal Queue to send Message instances to the listener
+    #
+    # ==== Return
+    # Queue instance
+    def queue
+      @queue ||= Queue.new
+    end
+
+    ##
+    # Process the data retrieved, formatting the raw data into one or more Connfu::Message instances
+    #
+    # ==== Parameters
+    # * +chunk+ data got from the HTTP stream
+    #
+    # ==== Return
+    # * Array of Connfu::Message instances
+    # * nil if invalid data
+    def handle_data(chunk)
+      if chunk.nil?
+        logger.info("Unable to process nil data")
+        return nil
+      end
+      logger.debug("raw data #{chunk}")
+      chunk = chunk.split("\n") # more than one event can be retrieved separated by '\n'
+      if chunk.is_a?(Array)
+        events = []
+        temp_events = []
+        chunk.each { |value|
+          json = ActiveSupport::JSON.decode(value)
+          if json
+            unless json.is_a?(Array) # Twitter - RSS message
+              unless json.nil?
+                logger.debug("#{self.class} Got a twitter message")
+                temp_events << @formatter.format_message(json)
+                temp_events.nil? or events << temp_events.flatten
+              else
+                logger.debug("#{self.class} Invalid data received")
+                events = nil
+              end
+            else # Voice - SMS message
+              logger.debug("#{self.class} Got a voice/sms message")
+              logger.debug(json)
+              temp_events = @formatter.format_voice_sms(json)
+              temp_events.nil? or events << temp_events.flatten
+            end
+          end
+        }
+        events.flatten
+      else
+        logger.info("#{self.class} Invalid data received #{chunk}")
+        nil
+      end
+    end
+
+    ##
+    # Insert an array of messages in the queue
+    # ==== Parameters
+    # * +events+ array of incoming events
+    def message(events)
+      if events.is_a?(Array)
+        events.each { |msg|
+          if msg.is_a?(Connfu::Message)
+            logger.debug("#{self.class} Inserting message in the queue")
+            logger.debug msg.to_s
+            queue << msg
+          else
+            logger.info("Invalid message type #{msg.class}")
+          end
+        }
+      end
+    end
+
+    ##
+    # Headers to send to authenticate
+    def headers
+      {"accept" => "application/json",
+       "authorization" => "Backchat #{@api_key}",
+       "Connection" => "Keep-Alive"}
+    end
+
+  end
+end