octocore-cassandra 0.0.6

data/bin/fakestream-cassandra

@@ -0,0 +1,258 @@
+#!/usr/bin/env ruby
+#
+# A simple utility to generate fake stream of data
+#
+# Usage:
+#   ./fakestream
+
+require 'net/http'
+require 'json'
+require 'octocore'
+
+module Octo
+  class FakeStream
+
+    MAX_USERS = 100
+
+    MAX_PAGES = 30
+    MAX_PRODUCTS = 200
+
+    MAX_CATEGORIES = 10
+
+    MAX_TAGS = 15
+
+
+    #How many no. of pages to view before going to product page
+    MAX_PAGES_TO_VISIT = 3
+
+    # Initialize with the URL
+    def initialize
+      @_apikeys = {}
+    end
+
+    def base_url
+      Octo.get_config(:base_url)
+    end
+
+    def stream
+      user = fakeuser
+
+      # simulate an app login
+      app_init user
+      # simulate a random number of page views before going to product
+      for i in 1..(1+rand(MAX_PAGES_TO_VISIT))
+        pv user, fakepage(user.enterprise)
+      end
+
+      # simulate a product page view
+      ppv user, fakeproduct(user.enterprise)
+
+
+      #visit a page or not after going to the product page
+      for i in 0..rand(2)
+        pv user, fakepage(user.enterprise)
+      end
+
+      puts "---- Next User ----"
+    end
+
+    def stream_forever
+      while 1
+        stream
+      end
+    end
+
+    private
+
+    # Create an APP INIT request
+    def app_init(user)
+      payload = {
+          userId: user.id,
+          phoneDetails: phonedetails
+      }
+      key = apikey(user.enterprise)
+      url = '/events/app.init/'
+      post(url, key, payload)
+    end
+
+    # Create a page view request
+    def pv(user, page)
+      payload = {
+          userId: user.id,
+          phoneDetails: phonedetails,
+          routeUrl: page.routeurl,
+          categories: fakecategories,
+          tags: faketags,
+      }
+      key = apikey user.enterprise
+      url = '/events/page.view/'
+      post(url, key, payload)
+    end
+
+
+    # Create a product page view request
+    def ppv(user, product)
+      payload = {
+          userId: user.id,
+          phoneDetails: phonedetails,
+          routeUrl: product.routeurl,
+          categories: fakecategories,
+          tags: faketags,
+          productId: product.id,
+          productName: product.name,
+          price: product.price
+      }
+      key = apikey user.enterprise
+      url = '/events/productpage.view/'
+      post(url, key, payload)
+    end
+
+    # Hash containing phone details
+    # @return [Hash]
+    def phonedetails
+      {
+          deviceId: 'FCDBD8EF-62FC-4ECB-B2F5-92C9E79AC7F9',
+          manufacturer: 'Apple',
+          model: 'iPhone 6',
+          latitude: 28.6139,
+          longitude: 77.209
+      }
+    end
+
+    # Creates a fake user for the enterprise on the fly
+    # @param [Octo::Enterprise] enterprise
+    # @return [Octo::User]
+    def fakeuser(enterprise = enterprises.to_a.sample)
+      Octo::User.new(enterprise_id: enterprise.id,
+                     id: rand(MAX_USERS))
+    end
+
+    # Generates a fake page for the enterprise
+    # @param [Octo::Enterprise] enterprise
+    # @return [Octo::Product]
+    def fakepage(enterprise)
+      id = rand(MAX_PAGES)
+      Octo::Page.new(
+          enterprise_id: enterprise.id,
+          routeurl: "/PageUrl/#{ id }",
+          categories: fakecategories,
+          tags: faketags
+      )
+    end
+
+
+    # Generates a fake product for the enterprise
+    # @param [Octo::Enterprise] enterprise
+    # @return [Octo::Product]
+    def fakeproduct(enterprise)
+      id = rand(MAX_PRODUCTS)
+      Octo::Product.new(
+          enterprise_id: enterprise.id,
+          id: id,
+          price: rand(10000).to_f,
+          name: "Fake Product #{ id }",
+          routeurl: "/Some/Url/#{ id }",
+          categories: fakecategories,
+          tags: faketags
+      )
+    end
+
+    # Generates fake categories
+    # @return [Array<String>] Array of fake categories
+    def fakecategories(count = 2)
+      (0..MAX_CATEGORIES).to_a.sample(count).collect { |x| "Fake Category #{ x }"}
+    end
+
+    # Generates fake tags
+    # @return [Array<String>] Array of fake tags
+    def faketags(count = 2)
+      (0..MAX_TAGS).to_a.sample(count).collect { |x| "Fake Tag #{ x }"}
+    end
+
+    # Fetches the APIKey for the enterprise
+    def apikey(enterprise)
+      unless @_apikeys.has_key?(enterprise.id)
+        @_apikeys[enterprise.id] = Octo::Authorization.find_by_username(enterprise.name).apikey
+      end
+      @_apikeys[enterprise.id]
+    end
+
+    # Creates the URI
+    def uri(url = base_url)
+      URI(url)
+    end
+
+    # Find all enterprises
+    # @return [Cequel::RecordSet]
+    def enterprises
+      Octo::Enterprise.all.select { |x| !x.name.nil? and x.fakedata? }
+    end
+
+    # Make the POST call
+    # @param [String] url The endpoint url
+    # @param [String] apikey The API Key
+    # @param [Hash] payload The payload
+    def post(url, apikey, payload)
+      headers = {
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json',
+          'apikey' => apikey
+      }
+
+      _uri = uri(base_url + url)
+      req = Net::HTTP::Post.new(_uri, headers)
+      req.content_type = 'application/json'
+      req.body = payload.to_json
+
+      res = Net::HTTP.start(_uri.hostname, _uri.port) do |http|
+        http.request(req)
+      end
+
+      case res
+        when Net::HTTPSuccess, Net::HTTPRedirection
+          puts res.body
+        else
+          puts res.value
+      end
+
+    end
+
+  end
+end
+
+# All the main Job
+def _main(config_file)
+
+  # setup signal trap
+  Signal.trap('INT') {
+    puts 'Halting on user request'
+    exit
+  }
+
+  # connect Octo and start the show
+  Octo.connect_with config_file
+  streamer = Octo::FakeStream.new
+  streamer.stream_forever
+end
+
+def main
+  config_file = if ARGV[0]
+                  ARGV[0]
+                else
+                  spec = Gem::Specification.find_by_name('octocore')
+                  gem_root = spec.gem_dir
+                  File.join(gem_root, 'lib', 'octocore' ,'config')
+                end
+  puts config_file
+  if File.exist?config_file
+    _main(config_file)
+  else
+    puts "Config file '#{ config_file }' does not exist. Exiting..."
+  end
+end
+
+main
+
+if __FILE__ == $0
+  main
+end

data/bin/octocore-admin-cassandra

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+#
+# A simple utility to provide easy migrations, reset
+# and all the rake tasks that you may need to do
+
+# ./octocore-admin --tasks
+
+require 'open3'
+
+module Octo
+  module CliAdmin
+
+    VALID_ACTIONS = %w(init migrate reset)
+
+    module ClassMethods
+      def perform(action, config_dir)
+        if VALID_ACTIONS.include?(action)
+          cmd = ['rake', '-f', spec.gem_dir + '/Rakefile',
+                '--verbose', "octo:#{ action }",
+                "CONFIG_DIR=#{ config_dir }"]
+          #STDOUT.puts "** Executing: #{ cmd }"
+          Open3.popen3(*cmd) do |stdout, stderr, status, thread|
+            stderr.sync = true
+            while line=stderr.gets do
+              puts(line)
+            end
+          end
+        else
+          STDOUT.puts "Invalid action: #{ action }"
+        end
+      end
+
+      def spec
+        @spec ||= Gem::Specification.find_by_name 'octocore'
+      end
+    end
+
+    class Cli
+      extend ClassMethods
+    end
+
+    def self.main
+      STDOUT.sync = true
+      action = ARGV[0]
+      config_dir = ARGV[1]
+      Octo::CliAdmin::Cli.perform(action, config_dir)
+    end
+
+  end
+end
+
+
+Octo::CliAdmin.main
+

data/lib/octocore-cassandra.rb

@@ -0,0 +1,152 @@
+require 'cequel'
+require 'yaml'
+require 'logger'
+
+require 'octocore-cassandra/version'
+require 'octocore-cassandra/config'
+
+
+require 'octocore-cassandra/models'
+require 'octocore-cassandra/counter'
+require 'octocore-cassandra/email'
+require 'octocore-cassandra/utils'
+
+require 'octocore-cassandra/trendable'
+require 'octocore-cassandra/baseline'
+require 'octocore-cassandra/trends'
+require 'octocore-cassandra/kldivergence'
+require 'octocore-cassandra/segment'
+
+# Mailer and scheduler should always be required in the following order
+require 'octocore-cassandra/mailer'
+require 'octocore-cassandra/scheduler'
+
+require 'octocore-cassandra/message_parser'
+
+require 'octocore-cassandra/schedeuleable'
+require 'octocore-cassandra/helpers'
+require 'octocore-cassandra/kafka_bridge'
+require 'octocore-cassandra/stats'
+
+# The main Octo module
+module Octo
+
+  # Connect using the provided configuration. If you want to extend Octo's connect
+  #   method you can override this method with your own. Just make sure to make
+  #   a call to self._connect(configuration) so that Octo also connects
+  # @param [Hash] configuration The configuration hash
+  def self.connect(configuration)
+    self._connect(configuration)
+  end
+
+  # Connect by reading configuration from the provided file
+  # @param [String] config_file Location of the YAML config file
+  def self.connect_with_config_file(config_file)
+    config = YAML.load_file(config_file).deep_symbolize_keys
+    self.connect(config)
+  end
+
+  # Connect by reading configuration files from the given directory.
+  #   In this case, all *.y*ml files would be read in
+  #   Dir.glob order and merged into one unified config
+  def self.connect_with_config_dir(config_dir)
+    config = {}
+    accepted_formats = Set.new(['.yaml', '.yml'])
+    Dir[config_dir + '/*'].each do |file_obj|
+      if File.file?(file_obj) and accepted_formats.include?File.extname(file_obj)
+        config = self.true_load(config, file_obj, config_dir)
+      elsif File.directory?(file_obj)
+        Dir[file_obj + '/**/*.y*ml'].each do |file|
+          config = self.true_load(config, file, config_dir)
+        end
+      end
+    end
+    # As a cleanup step, merge the values of key named "config"
+    # with the global config hash
+    configConfig = config.delete(:config)
+    config = config.deep_merge(configConfig)
+    # Now, good to merge the two
+    self.connect config
+  end
+
+  # Loads the true config. The true config is the hierarchial config
+  # @param [Hash] config The base config. Loaded config will be deep merged
+  #   with this
+  # @param [String] file The file from which config should be loaded
+  # @param [String] config_fir The config dir in which the file is located
+  # @return [Hash] The merged config hash
+  def self.true_load(config, file, config_dir)
+    _config = YAML.load_file file
+    if _config
+      $stdout.puts "Loading from Config file: #{ file }"
+      # A little bit of hack here.
+      # This hack makes sure that if we load config files from nestes
+      # directories, the corresponding config is loaded in
+      # hierarchy.
+      # So, if the file is like /config/search/index.yml, the
+      # key would be like [config[search[index]]]
+      a = file.gsub(/(\/?#{config_dir}(\/)*(config\/)*|.yml)/, '').split('/')
+      _true_config = a.reverse.inject(_config) { |r,e| { e => r } }
+      config = config.deep_merge(_true_config.deep_symbolize_keys)
+    end
+    config
+  end
+
+  # Provides a unified interface to #connect_with_config_dir
+  #   and #connect_with_config_file for convenience
+  def self.connect_with(location)
+    if File.directory?(location)
+      self.connect_with_config_dir location
+    elsif File.file?(location)
+      self.connect_with_config_file location
+    else
+      puts "Invalid location #{ location }"
+    end
+  end
+
+
+  # A low level method to connect using a configuration
+  # @param [Hash] configuration The configuration hash
+  def self._connect(configuration)
+
+    load_config configuration
+
+    self.logger.info('Octo booting up.')
+
+    # Establish Cequel Connection
+    cassandra_config = Octo.get_config(:cassandra)
+    connection = Cequel.connect(cassandra_config)
+    Cequel::Record.connection = connection
+
+    # Establish connection to cache server
+    default_cache = {
+      host: '127.0.0.1', port: 6379
+    }
+    cache_config = Octo.get_config(:redis, default_cache)
+    Cequel::Record.update_cache_config(*cache_config.values_at(:host, :port))
+
+    # Establish connection to statsd server if required
+    if configuration.has_key?(:statsd)
+      statsd_config = configuration[:statsd]
+      set_config :stats, Statsd.new(*statsd_config.values)
+    end
+
+    self.logger.info('I\'m connected now.')
+    require 'octocore-cassandra/callbacks'
+
+    self.logger.info('Setting callbacks.')
+
+    Octo::Callbacks.run_hook(:after_connect)
+  end
+
+  # Creates a logger for Octo
+  def self.logger
+    unless @logger
+      @logger = Logger.new(Octo.get_config(:logfile, $stdout)).tap do |log|
+        log.progname = name
+      end
+    end
+    @logger
+  end
+
+end