octocore-cassandra 0.0.6

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

@@ -0,0 +1,168 @@
+module Octo
+  module Counter
+    module Helper
+
+
+      #The prefix to use when converting a type constant into an
+      #aggregator method name
+      METHOD_PREFIX = 'aggregate'
+
+
+      # Defined the method names for the type counters.
+      def type_counters_method_names(type = nil)
+        if type.nil?
+          get_typecounters.map do |typ|
+            [METHOD_PREFIX, typ.to_s.downcase].join('_')
+          end
+        else
+          [METHOD_PREFIX, type.to_s.downcase].join('_')
+        end
+      end
+
+      # Get all the type counters i.e. TYPE_MINUTE_30 etc from
+      #   Counter class.
+      # @return [Array] Array of all the constants that define a counter type
+      def get_typecounters
+        max = max_type
+        Counter.constants.select do |x|
+          if x.to_s.start_with?('TYPE')
+            Counter.const_get(x) <= max
+          else
+            false
+          end
+        end
+      end
+
+      # Define the max granularity that should exist
+      def max_type(type = nil)
+        if @max_type
+          @max_type
+        else
+          if type
+            @max_type = type
+          else
+            @max_type = 9
+          end
+        end
+        @max_type
+      end
+
+      # Coverts the method name to the constant type
+      # @param [String] method_name The method name to convert into constant
+      # @return [Symbol] The constant
+      def method_names_type_counter(method_name)
+        prefix, *counterType = method_name.to_s.split('_')
+        if prefix == METHOD_PREFIX
+          cnst = counterType.join('_').upcase.to_sym
+          string_to_const_val(cnst)
+        end
+      end
+
+      # Converts a string (which may represent a counter constant) into its
+      #   corresponding constant
+      # @param [String] cnst The string which may represent a constant
+      # @return [Fixnum] The constant value; iff the string represent a constant.
+      #   Nil otherwise
+      def string_to_const_val(cnst)
+        index = Counter.constants.index(cnst)
+        if index
+          Counter.const_get(cnst)
+        end
+      end
+
+      # Generates a fromtype for a totype. This defines the relation
+      #  of aggregation needed for the counters.
+      def get_fromtype_for_totype(totype)
+        case totype
+          when TYPE_MINUTE_30
+            TYPE_MINUTE
+          when TYPE_HOUR
+            TYPE_MINUTE_30
+          when TYPE_HOUR_3
+            TYPE_HOUR
+          when TYPE_HOUR_6
+            TYPE_HOUR_3
+          when TYPE_HOUR_12
+            TYPE_HOUR_6
+          when TYPE_DAY
+            TYPE_HOUR_6
+          when TYPE_DAY_3
+            TYPE_DAY
+          when TYPE_DAY_6
+            TYPE_DAY_3
+          when TYPE_WEEK
+            TYPE_DAY_3
+          else
+            TYPE_WEEK
+        end
+      end
+
+      # Gets the duration for a particular counter type. This helps in
+      #    aggregation.
+      # @param [Fixnum] type The counter type
+      # @param [Time] ts The time at wich duration needs to be passed
+      # @return [Time] The time or time range for the given specs
+      def get_duration_for_counter_type(type, ts=Time.now.ceil)
+        start_time, step =  case type
+                              when TYPE_MINUTE
+                                [2.minute.ago, 1.minute]
+                              when TYPE_MINUTE_30
+                                [30.minute.ago, 1.minute]
+                              when TYPE_HOUR
+                                [1.hour.ago, 30.minute]
+                              when TYPE_HOUR_3
+                                [3.hour.ago, 1.hour]
+                              when TYPE_HOUR_6
+                                [6.hour.ago, 3.hour]
+                              when TYPE_HOUR_12
+                                [12.hour.ago, 6.hour]
+                              when TYPE_DAY
+                                [1.day.ago, 6.hour]
+                              when TYPE_DAY_3
+                                [3.day.ago, 1.day]
+                              when TYPE_DAY_6
+                                [6.day.ago, 3.day]
+                              when TYPE_WEEK
+                                [1.week.ago, 1.week]
+                            end
+        start_time.ceil.to(ts, step)
+      end
+
+      # Returns the mapping for counters as text
+      # @return [Hash]
+      def self.counter_text
+        {
+          TYPE_MINUTE => 'Near Real Time',
+          TYPE_MINUTE_30 => '30 Minute',
+          TYPE_HOUR => 'Hourly',
+          TYPE_HOUR_3 => '3 Hourly',
+          TYPE_HOUR_6 => '6 Hourly',
+          TYPE_HOUR_12 => '12 Hourly',
+          TYPE_DAY => 'Daily',
+          TYPE_DAY_3 => '3 Days',
+          TYPE_DAY_6 => '6 Days',
+          TYPE_WEEK => 'Weekly'
+        }
+      end
+
+      # Generate aggregator methods for a class. You can pass
+      # your own block to generator for all custom needs.
+      # Check out the implementation at Octo::Counter#countables
+      # or Octo::Trends#trendable
+      # @param [Block] block The block to be evaluated while executing
+      #   the method
+      def generate_aggregators(&block)
+        @stored_block = block
+        type_counters_method_names.each do |method_name|
+          singleton_class.module_eval(<<-RUBY, __FILE__, __LINE__+1)
+            def #{ method_name } (ts=Time.now.floor)
+              bl = self.instance_variable_get(:@stored_block)
+              instance_exec(ts, __method__, &bl) if bl
+            end
+          RUBY
+        end
+      end
+
+    end
+  end
+end

data/lib/octocore-cassandra/email.rb

@@ -0,0 +1,63 @@
+require 'mandrill'
+require 'resque'
+require 'resque-scheduler'
+
+module Octo
+
+  # Octo Email Sender
+  module Email
+
+    # Send Emails using mandrill api
+    # @param [Text] email Email Address of the receiver
+    # @param [Text] subject Subject of Email
+    # @param [Hash] opt Hash contain other message details
+    def send(email, subject, opts = {})
+      if email.nil? or subject.nil?
+        raise ArgumentError, 'Email Address or Subject is missing'
+      else
+        message = {
+          from_name: Octo.get_config(:email_sender).fetch(:name),
+          from_email: Octo.get_config(:email_sender).fetch(:email),
+
+          subject: subject,
+
+          text: opts.fetch('text', nil),
+          html: opts.fetch('html', nil),
+
+          to: [{
+            email: email,
+            name: opts.fetch('name', nil)
+          }]
+        }
+        # Pass the message to resque only when mandrill key is present
+        _mandrill_config = ENV['MANDRILL_API_KEY'] || Octo.get_config(:mandrill_api_key)
+        if _mandrill_config and !_mandrill_config.empty?
+          enqueue_msg(message)
+        end
+      end
+    end
+
+    # Adding Email details to Resque Queue
+    # @param [Hash] message Hash contain message details
+    def enqueue_msg(message)
+      Resque.enqueue(Octo::EmailSender, message)
+    end
+
+  end
+
+  # Class to perform Resque operations for sending email
+  class EmailSender
+
+    @queue = :email_sender
+
+    # Resque Perform method
+    # @param [Hash] message The details of email
+    def self.perform(message)
+      _mandrill_config = ENV['MANDRILL_API_KEY'] || Octo.get_config(:mandrill_api_key)
+      m = Mandrill::API.new _mandrill_config
+      m.messages.send message
+    end
+
+  end
+end
+

data/lib/octocore-cassandra/featureflag.rb

@@ -0,0 +1,79 @@
+require 'set'
+
+module Octo
+
+  # The FeatureFlag Module
+  #
+  #   This module flags some functionalities as OFF or DISABLED state.
+  module FeatureFlag
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      # Set the featureflag for a module or class to the state. If the
+      #   featureflag is set to true, it means that the feature is disabled. If
+      #   the featureflag is set to false, it means that the feature is enabled.
+      #
+      #   It also defined a `is_flagged?` method on the module which returns
+      #   the state of featureflag
+      #
+      # @param [Module] klass The class or module to be feature flagged
+      # @param [Boolean] state The boolean state to set for the class
+      #
+      def featureflag(klass, state)
+        if state
+          unless flags.include?klass
+            flags << klass
+            klass.instance_eval do
+              def is_flagged?
+                true
+              end
+            end
+          end
+        else
+          if flags.include?klass
+            flags.delete(klass)
+            klass.instance_eval do
+              def is_flagged?
+                false
+              end
+            end
+          end
+        end
+      end
+
+      # Get the list of all flags
+      # @return [Set] A set of all flags
+      #
+      def flags
+        @flags ||= Set.new([])
+      end
+
+      # Helper method to find if a module is feature flagged or not
+      # @param [Module] feature The module to be tested
+      # @return [Boolean] Boolean value specifying if the feature is flagged
+      #   or not
+      #
+      def is_flagged?(feature)
+        flags.include?feature
+      end
+
+      # Returns if the flag is not set
+      # @param [Module] feature The module to be tested
+      # @return [Boolean] Boolean value specifying the status
+      #
+      def is_not_flagged?(feature)
+        !is_flagged?feature
+      end
+    end
+
+  end
+
+  #include FeatureFlag
+end
+
+Octo.send(:include, Octo::FeatureFlag)
+

data/lib/octocore-cassandra/helpers.rb

@@ -0,0 +1,6 @@
+require 'octocore-cassandra/helpers/api_helper'
+require 'octocore-cassandra/helpers/api_logger'
+require 'octocore-cassandra/helpers/api_consumer_helper'
+require 'octocore-cassandra/helpers/client_helper'
+require 'octocore-cassandra/helpers/kong_helper'
+require 'octocore-cassandra/helpers/sinatra_helper'

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

@@ -0,0 +1,51 @@
+require 'redis'
+require 'set'
+
+module Octo
+  module Helpers
+
+    # Helper Module for Octo Consumer
+    module ApiConsumerHelper
+
+      # Get all the valid events
+      # @return [Set<Symbol>] Valid events globally
+      def valid_events
+        Set.new(Octo.get_config(:allowed_events))
+      end
+
+      # Get the API events. These are the ones that the client is billed for
+      #   This should eventually be placed under kong helpers when that is
+      #   ready.
+      # @return [Set<Symbol>] Set of api_events
+      # def api_events
+      #   Set.new(%w(app.init app.login app.logout page.view productpage.view update.profile))
+      # end
+
+      # Handles Kafka messages and perform required operations
+      # @param [Hash] msg Hash Message
+      def handle(msg)
+        msg_obj = Octo::Message::Message.new(msg)
+        msg = msg_obj.to_h
+        begin
+          eventName = msg[:event_name]
+          if (valid_events.include?eventName)
+            call_hooks(eventName, msg)
+          end
+        rescue Exception => e  
+          puts e.message
+          puts e.backtrace.inspect
+        end
+      end
+
+      # Set Octo callbacks
+      # @param [String] event Event name
+      # @param [Hash] *args Points to the messsage hash
+      def call_hooks(event, *args)
+        hook = [:after, event.gsub('.', '_')].join('_').to_sym
+        Octo::Callbacks.run_hook(hook, *args)
+      end
+
+    end
+  end
+end
+

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

@@ -0,0 +1,65 @@
+require 'securerandom'
+require 'octocore-cassandra'
+require 'octocore-cassandra/stats'
+
+module Octo
+  module Helpers
+    module ApiHelper
+
+      include Octo::Stats
+
+      KONG_HEADERS = %w(HTTP_X_CONSUMER_ID HTTP_X_CONSUMER_CUSTOM_ID HTTP_X_CONSUMER_USERNAME)
+
+      # Get enterprise details from the HTTP headers that Kong sets
+      # @return [Hash] The hash of enterprise details
+      def enterprise_details
+        kong_config = Octo.get_config :kong
+        if kong_config[:enabled]
+          KONG_HEADERS.inject({}) do |r, header|
+            key = header.gsub('HTTP_X_CONSUMER_', '').downcase
+            r[key] = request.env.fetch(header, nil)
+            r
+          end
+        else
+          apikey = request.env.fetch('HTTP_APIKEY')
+          {custom_id: settings.redis.get(apikey)}
+        end
+      end
+
+      # Gets the POSTed parameters from rack env
+      # @return [Hash] A hash of POSTed parameters
+      def post_params
+        instrument(:json_parse) do
+         JSON.parse(request.env['rack.input'].read)
+        end
+      end
+
+      # Generate a UUID for each response
+      # @return [String] UUID
+      def uuid
+        SecureRandom.uuid
+      end
+
+      # Process an incoming request
+      # @param [String] event_name The name of the event
+      # @return [JSON] The json return value after processing
+      def process_request(event_name)
+        postparams = post_params
+        opts = {
+          event_name: event_name,
+          enterprise: enterprise_details,
+          uuid: uuid
+        }
+        postparams.merge!(opts)
+        kafka_config = Octo.get_config :kafka
+        if kafka_config[:enabled]
+          settings.kafka_bridge.push(postparams)
+        else
+          settings.queue.push(JSON.dump(postparams))
+        end
+        { eventId: opts[:uuid] }.to_json
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'logger'
+
+module Octo
+  class ApiLogger
+    def self.logger
+      if @_logger.nil?
+        @_logger = Logger.new STDOUT
+        @_logger.level = Logger::INFO
+        @_logger.datetime_format = '%a %d-%m-%Y %H%M '
+      end
+      @_logger
+    end
+  end
+end