octocore-cassandra 0.0.6

data/lib/octocore-cassandra/helpers/client_helper.rb

@@ -0,0 +1,104 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'digest/sha1'
+require 'securerandom'
+require 'octocore-cassandra/models'
+
+module Octo
+  module Helpers
+    module ClientHelper
+
+      # Create a new Client
+      # @param [String] username The name of the client
+      # @param [String] email The email of the client
+      # @param [String] password The password of the client
+      # @return [String] The status of request
+      def add_consumer(username, email, password)
+        unless enterprise_name_exists?(username)
+
+          # create enterprise
+          e = Octo::Enterprise.new
+          e.name = username
+          e.save!
+
+          enterprise_id = e.id.to_s
+
+          # create its Authentication stuff
+          auth = Octo::Authorization.new
+          auth.enterprise_id = enterprise_id
+          auth.username = e.name
+          auth.email = email
+          custom_id = enterprise_id
+          auth.password = password
+          auth.save!
+          'success'
+        else
+          'Not creating client as client name exists'
+        end
+      end
+
+      # Validate Client authentication
+      # @param [String] username The name of the client
+      # @param [String] password The password of the client
+      # @return [Boolean] Authenticated or not
+      def validate_password( username, password)
+        consumer = fetch_consumer(username)
+        hash_password = Digest::SHA1.hexdigest(password + consumer.enterprise_id)
+        hash_password == consumer.password
+      end
+
+      # check enterprise exist
+      # @param [String] enterprise_name The name of the enterprise
+      # @return [Boolean] Exist or not
+      def enterprise_name_exists?(enterprise_name)
+        Octo::Enterprise.all.select { |x| x.name == enterprise_name}.length > 0
+      end
+
+      # fetch client data
+      # @param [String] username The name of the client
+      # @return [Hash] Client Data
+      def fetch_consumer(username)
+        Octo::Authorization.where(username: username).first
+      end
+
+      # Validate Client session
+      # @param [String] username The name of the client
+      # @param [String] token The session token of the client
+      # @return [Boolean] Authenticated or not
+      def validate_token(username, token)
+        Octo::Authorization.all.select do |x| 
+          x.username == username &&
+          x.session_token == token
+        end.length > 0
+      end
+
+      # Create new client session
+      # @param [String] username The name of the client
+      # @return [String] Session Token
+      def save_session(username)
+        consumer = fetch_consumer(username)
+        consumer.session_token = SecureRandom.hex
+        consumer.save!
+        consumer.session_token.to_s
+      end
+
+      # Destroy client session
+      # @param [String] username The name of the client
+      def destroy_session(username)
+        consumer = fetch_consumer(username)
+        consumer.session_token = nil
+        consumer.save!
+      end
+
+      # check user is admin or client
+      # @param [String] username The username of the client
+      # @return [Boolean] Is Admin or not
+      def check_admin(username)
+        consumer = fetch_consumer(username)
+        consumer.admin
+      end
+
+    end
+  end
+end

data/lib/octocore-cassandra/helpers/kong_helper.rb

@@ -0,0 +1,164 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'digest/sha1'
+require 'securerandom'
+
+module Octo
+  module Helpers
+    module KongHelper
+
+      # The default URL for kong to connect to
+      KONG_URL = 'http://127.0.0.1:8001'
+
+      # Fetch Kong URL
+      # @return [String] Kong URL
+      def kong_url
+        kong_config = Octo.get_config :kong
+        if kong_config.class == String
+          kong_config
+        elsif kong_config.class == Hash
+          kong_config.fetch :url, KONG_URL
+        end
+      end
+
+      # Process Every Kong Request
+      # @param [String] url The url of the kong request
+      # @param [Key] method The request method
+      # @param [Hash] payload The request body
+      # @return [Hash] Response
+      def process_kong_request (url, method, payload)
+        begin
+          url = kong_url + url
+          header = {
+            'Accept' => 'application/json, text/plain, */*',
+            'Content-Type' => 'application/json'
+          }
+          uri = URI.parse(URI.encode(url.strip))
+          http = Net::HTTP.new(uri.host,uri.port)
+
+          case method
+          when :GET
+            req = Net::HTTP::Get.new(uri, header) # GET Method
+          when :POST
+            req = Net::HTTP::Post.new(uri.path, header) # POST Method
+          when :PUT
+            req = Net::HTTP::Put.new(uri.path, header) # PUT Method
+          when :PATCH
+            req = Net::HTTP::Patch.new(uri.path, header) # PATCH Method
+          when :DELETE
+            req = Net::HTTP::Delete.new(uri.path, header) # DELETE Method
+          else
+            # Default Case
+          end
+
+          puts "HTTP #{ method } to #{ uri.host}:#{ uri.port }. Body: #{ payload.to_json }"
+          body = "#{ payload.to_json }"
+          res = http.request(req, body)
+          if res.body
+            JSON.parse(res.body) # Returned Data
+          else
+            {}
+          end
+        rescue Exception => e
+          puts "Exception: " + e.message.to_s + "\n" + e.backtrace_locations.join("\n")  + "}"
+          { message: e.to_s }.to_json
+        end
+      end
+
+      # Add Key of client for Key Authorization
+      # @param [String] username The username of the client
+      # @param [String] keyauth_key The Authorization key of the client
+      # @return [Hash] Response
+      def create_keyauth(username, keyauth_key)
+
+        url = '/consumers/'+ username +'/key-auth'
+        payload = {
+          key: keyauth_key
+        }
+        process_kong_request(url, :POST, payload)
+      end
+
+      # Add a Kong ratelimiting plugin
+      # @param [String] apikey The apikey of the client
+      # @param [String] consumer_id The consumer_id of the client
+      # @param [String] config The configuration of the plugin
+      # @return [String] Plugin Id
+      def add_ratelimiting_plugin(apikey, consumer_id, config)
+
+        url = '/apis/' + apikey + '/plugins/'
+        payload = {
+          name: "rate-limiting",
+          consumer_id: consumer_id,
+          config: config
+        }
+
+        response = process_kong_request(url, :POST, payload)
+
+        if response['id']
+          response['id'].to_s
+        end
+      end
+
+      # List of Client
+      # @param [Hash] payload The payload to send
+      # @return [Hash] All the clients data
+      def consumerlist(payload = {})
+        url = '/consumers/'
+        res = process_kong_request(url, :GET, payload)
+        res['data']
+      end
+
+      # Delete Consumers from Kong
+      # @param [String] username The username of the Client
+      # @return [String] Status
+      def delete_consumer(username)
+        url = '/consumers/' + username
+        payload = {}
+        process_kong_request(url, :DELETE, payload)
+      end
+
+      # List of APIS
+      # @param [Hash] payload filter values
+      # @return [Hash] All the apis data
+      def apislist(payload = {})
+        url = '/apis/'
+        res = process_kong_request(url, :GET, payload)
+        res['data']
+      end
+
+      # Delete apis from Kong
+      # @param [String] name The name of the api
+      # @return [String] Status
+      def delete_api(name)
+        url = '/apis/' + name
+        payload = {}
+        process_kong_request(url, :DELETE, payload)
+      end
+    end
+
+    # This class acts as the bridge between Octo and Kong
+    class KongBridge
+      extend KongHelper
+
+      class << self
+
+        # Method to delete all consumers and apis
+        def delete_all
+          unless apislist.nil?
+            apislist.each do |api|
+              delete_api(api['name'])
+            end
+          end
+
+          unless consumerlist.nil?
+            consumerlist.each do |consumer|
+              delete_consumer(consumer['username'])
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/octocore-cassandra/helpers/sinatra_helper.rb

@@ -0,0 +1,22 @@
+require 'octocore-cassandra'
+
+module Octo
+  module Sinatra
+    module Helper
+
+      # The headers on which kong sends the authenticated details
+      KONG_AUTH_HEADERS = %w(HTTP_X_CONSUMER_ID HTTP_X_CONSUMER_CUSTOM_ID HTTP_X_CONSUMER_USERNAME)
+
+      # Finds the enterprise details
+      # #return [Array<String>] Enterprise's Id, Custom Name and User Name
+      def enterprise_details
+        KONG_AUTH_HEADERS.collect do |prop|
+          request.env.fetch(prop, nil)
+        end
+      end
+
+
+    end
+  end
+
+end

data/lib/octocore-cassandra/kafka_bridge.rb

@@ -0,0 +1,60 @@
+require 'ruby-kafka'
+
+module Octo
+  # The bridge between Kafka and ruby
+  class KafkaBridge
+
+    # These are hard wired
+    CLIENT_ID = ENV['KAFKA_CLIENT_ID']
+    TOPIC     = ENV['KAFKA_TOPIC']
+
+    MAX_BUFFER_SIZE = 20_000
+
+    MAX_QUEUE_SIZE = 10_000
+
+    DELIVERY_INTERVAL = 1
+
+    # Changes as per environment
+    BROKERS   = ENV['KAFKA_BROKERS'].try(:split, ',')
+
+    def initialize(opts = {})
+      opts.deep_symbolize_keys!
+      @kafka = ::Kafka.new(seed_brokers: opts.fetch(:brokers, BROKERS),
+                         client_id: opts.fetch(:client_id, CLIENT_ID)
+      )
+      @producer = @kafka.async_producer(
+        max_buffer_size: opts.fetch(:max_buffer_size, MAX_BUFFER_SIZE),
+        max_queue_size: opts.fetch(:max_queue_size, MAX_QUEUE_SIZE),
+        delivery_interval: opts.fetch(:delivery_interval, DELIVERY_INTERVAL),
+      )
+      if opts.has_key?(:topic)
+        @topic = opts[:topic]
+      else
+        @topic = TOPIC
+      end
+    end
+
+    def push(params)
+      create_message params
+    end
+
+    def teardown
+      @producer.shutdown
+    end
+
+    private
+
+    # Creates a new message.
+    # @param [Hash] message The message hash to be produced
+    def create_message(message)
+      begin
+        @producer.produce(JSON.dump(message), topic: @topic)
+      rescue Kafka::BufferOverflow
+        Octo.logger.error 'Buffer Overflow. Sleeping for 1s'
+        sleep 1
+        retry
+      end
+    end
+
+  end
+end

data/lib/octocore-cassandra/kldivergence.rb

@@ -0,0 +1,14 @@
+module Octo
+
+  module KLDivergence
+
+    # Calculates the KL-Divergance of two probabilities
+    # https://en.wikipedia.org/wiki/Kullback–Leibler_divergence
+    # @param [Float] p The first or observed probability
+    # @param [Float] q The second or believed probability. Must be non-zero
+    # @return [Float] KL-Divergance score
+    def kl_divergence(p, q)
+      p * Math.log(p/q)
+    end
+  end
+end

data/lib/octocore-cassandra/mailer.rb

@@ -0,0 +1 @@
+require 'octocore-cassandra/mailer/subscriber_mailer'

data/lib/octocore-cassandra/mailer/subscriber_mailer.rb

@@ -0,0 +1,30 @@
+require 'octocore-cassandra'
+
+module Octo
+  module Mailer
+    class SubscriberMailer
+      @queue = :subscriber_notifier
+
+      # Method for the scheduler to call
+      # Counts the number of subscriber in the last 24 hours
+      #  and then sends a mail with subscriber count to the
+      #  email mentioned
+
+      def perform (from=nil)
+        if from.nil?
+          subscribers = Octo::Subscriber.where(created_at: 24.hours.ago..Time.now.floor)
+        else
+          subscribers = Octo::Subscriber.where(created_at: from..Time.now.floor)
+        end
+        #   MAIL CODE
+        Octo.get_config(:email_to).each { |x|
+          opts1 = {
+              text: "Today number of new susbcribes are " + subscribers.length,
+              name: x.fetch('name')
+          }
+          Octo::Email.send(x.fetch('email'), subject, opts1)
+        }
+      end
+    end
+  end
+end

data/lib/octocore-cassandra/message_parser.rb

@@ -0,0 +1,114 @@
+require 'json'
+
+module Octo
+  # Message abstraction module
+  module Message
+
+    # Parsing kafka messages for octo consumer
+    module MessageParser
+
+      # Parsing Message hash in Octo compatible form
+      # @param [Hash] Message Hash
+      # @return [Hash] Hash in Octo form
+      def parse(msg)
+        msg = JSON.parse(msg)
+        m = { event_name: msg['event_name'] }
+        case msg['event_name']
+        when 'funnel_update'
+          m.merge!({
+                    rediskey: msg['rediskey']
+                  })
+        when 'update.profile'
+          m.merge!({
+                    profileDetails: msg['profileDetails']
+                  })
+        when 'page.view'
+          m.merge!({
+                    routeUrl:     msg['routeUrl'],
+                    categories:   msg.fetch('categories', []),
+                    tags:         msg.fetch('tags', [])
+                  })
+        when 'productpage.view'
+          m.merge!({
+                    routeUrl:     msg['routeUrl'],
+                    categories:   msg.fetch('categories', []),
+                    tags:         msg.fetch('tags', []),
+                    productId:    msg['productId'],
+                    productName:  msg['productName'],
+                    price:        msg['price']
+                  })
+        when 'update.push_token'
+          m.merge!({
+                    pushType:     msg['notificationType'],
+                    pushKey:      msg['pushKey'],
+                    pushToken:    msg['pushToken']
+                  })
+        end
+        enterprise = msg['enterprise']
+        raise StandardError, 'Parse Error' if enterprise.nil?
+
+        eid = if enterprise.has_key?'custom_id'
+                enterprise['custom_id']
+              elsif enterprise.has_key?'customId'
+                enterprise['customId']
+              end
+
+        ename = if enterprise.has_key?'user_name'
+                  enterprise['user_name']
+                elsif enterprise.has_key?'userName'
+                  enterprise['userName']
+                else
+                  nil
+                end
+        m.merge!({
+          id:             msg.fetch('uuid', nil),
+          enterpriseId:   eid,
+          enterpriseName: ename,
+          phone:          msg.fetch('phoneDetails', nil),
+          browser:        msg.fetch('browserDetails', nil),
+          userId:         msg.fetch('userId', -1),
+          created_at:     Time.now
+        })
+
+        m
+      end
+
+    end
+
+    # To handle message abstraction
+    class Message
+      include MessageParser
+
+      attr_reader :message
+      
+      # Converting Message hash in Octo compatible form
+      # @param [Hash] Message Hash
+      def initialize(msg)
+        @message = msg
+      end
+
+      # To get hash message
+      # @return [Hash] Message Hash
+      def to_h
+        parse(@message)
+      end
+
+      # To get enterprise id
+      # @return [String] Enterprise Id
+      def eid
+        msg = to_json
+        enterprise = msg['enterprise']
+        raise StandardError, 'Parse Error' if enterprise.nil?
+
+        eid = if enterprise.has_key?'custom_id'
+                enterprise['custom_id']
+              elsif enterprise.has_key?'customId'
+                enterprise['customId']
+              end
+
+        eid
+      end
+      
+    end
+  end
+end