octocore 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bcac24a9385b4c0d121884a5adeb0e82d00b1631
+  data.tar.gz: bcc0bcf99db9de3cf2b5072bc2d4df75caf09311
+SHA512:
+  metadata.gz: a0070adb0ba6bac071e6416f6588b4749bf445dba882a2a2a90ec1c3730c7adb2638dc561f4e7224b19bd2a2e3ef9c0c81407be98fd4423e39cba738a6a59d24
+  data.tar.gz: 8eb6efe92b8d54bc435d967268e608a4735e3d12fd2d6c20cb9262ed2f659d41993c09796f51fd8cdb8bcdd6b3cc7a5529c2da7082c87653bbb7ea0fedf35f34

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,117 @@
+PATH
+  remote: .
+  specs:
+    octocore (0.0.1)
+      cequel (~> 1.9, >= 1.9.0)
+      descriptive_statistics (~> 2.5.1, >= 2.5.0)
+      elasticsearch (~> 1.0.17, >= 1.0.17)
+      faraday (~> 0.9.2, >= 0.9.2)
+      hiredis (~> 0.6.1, >= 0.6.0)
+      hooks (~> 0.4.1, >= 0.4.1)
+      json (~> 1.8.1, >= 1.8.1)
+      rake (~> 11.1.0, >= 11.1.0)
+      redis (~> 3.2.2, >= 3.2.0)
+      resque (~> 1.26.0, >= 1.26.0)
+      resque-scheduler (~> 4.1.0, >= 4.1.0)
+      ruby-kafka (~> 0.3.2, >= 0.3.2)
+      statsd-ruby (~> 1.3.0, >= 1.3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.2.7)
+      activesupport (= 4.2.7)
+      builder (~> 3.1)
+    activesupport (4.2.7)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    builder (3.2.2)
+    cassandra-driver (2.1.6)
+      ione (~> 1.2)
+    cequel (1.10.0)
+      activemodel (~> 4.0)
+      cassandra-driver (~> 2.0)
+    descriptive_statistics (2.5.1)
+    diff-lcs (1.2.5)
+    elasticsearch (1.0.18)
+      elasticsearch-api (= 1.0.18)
+      elasticsearch-transport (= 1.0.18)
+    elasticsearch-api (1.0.18)
+      multi_json
+    elasticsearch-transport (1.0.18)
+      faraday
+      multi_json
+    faraday (0.9.2)
+      multipart-post (>= 1.2, < 3)
+    hiredis (0.6.1)
+    hooks (0.4.1)
+      uber (~> 0.0.14)
+    i18n (0.7.0)
+    ione (1.2.3)
+    json (1.8.3)
+    minitest (5.9.0)
+    mono_logger (1.1.0)
+    multi_json (1.12.1)
+    multipart-post (2.0.0)
+    parallel (1.9.0)
+    parallel_tests (2.5.0)
+      parallel
+    rack (1.6.4)
+    rack-protection (1.5.3)
+      rack
+    rake (11.1.2)
+    redis (3.2.2)
+    redis-namespace (1.5.2)
+      redis (~> 3.0, >= 3.0.4)
+    resque (1.26.0)
+      mono_logger (~> 1.0)
+      multi_json (~> 1.0)
+      redis-namespace (~> 1.3)
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+    resque-scheduler (4.1.0)
+      mono_logger (~> 1.0)
+      redis (~> 3.0)
+      resque (~> 1.25)
+      rufus-scheduler (~> 3.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    ruby-kafka (0.3.10)
+    rufus-scheduler (3.2.1)
+    sinatra (1.4.7)
+      rack (~> 1.5)
+      rack-protection (~> 1.4)
+      tilt (>= 1.3, < 3)
+    statsd-ruby (1.3.0)
+    thread_safe (0.3.5)
+    tilt (2.0.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    uber (0.0.15)
+    vegas (0.1.11)
+      rack (>= 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  octocore!
+  parallel_tests (~> 2.5.0, >= 2.5.0)
+  rspec (~> 3.4.0, >= 3.4.0)
+
+BUNDLED WITH
+   1.11.2

data/README.md

@@ -0,0 +1,50 @@
+# octo-core
+
+This is the Octomatic Enterprise Core gem. It provides most of the ORM stuff. Class and modules for different tables.
+
+
+**Rake Tasks**
+
+```bash
+rake cequel:keyspace:create  # Initialize Cassandra keyspace
+rake cequel:keyspace:drop    # Drop Cassandra keyspace
+rake octo:init               # Create keyspace and tables for all defined models
+rake octo:migrate            # Synchronize all models defined in `lib/octocore/models' with Cassandra database schema
+rake octo:reset              # Drop keyspace if exists, then create and migrate
+rake spec                    # Run RSpec code examples
+```
+
+# Building
+
+```bash
+./bin/clean_setup.sh
+```
+
+# Specs
+
+```
+lang=bash
+rake spec
+```
+
+# Verifying connectivity
+
+You can use the following set of commands in `irb` to verify all things working with this gem. Execute it from irb in PROJ_DIR.
+
+```ruby
+require 'octocore';config_dir = 'lib/octocore/config/';Octo.connect_with(config_dir);nil
+```
+
+# Creating fake stream
+
+It ships with a utility called `fakestream`. It will automatically stream random data. To use just open your console and type
+
+```
+fakestream
+```
+
+Optionally provide a config file for octo to connect as 
+
+```
+fakestream /path/to/octo_config.yml
+```

data/Rakefile

@@ -0,0 +1,138 @@
+require 'cequel'
+require 'yaml'
+require 'redis'
+require 'rspec/core/rake_task'
+
+require 'octocore/helpers/kong_helper'
+require 'octocore/config'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :environment do
+  config_dir = 'lib/octocore/config/'
+  config = {}
+  Dir[config_dir + '**{,/*/**}/*.yml'].each do |file|
+    _config = YAML.load_file(file)
+    if _config
+      puts "loading from file: #{ file }"
+      config = config.merge(_config.deep_symbolize_keys)
+    end
+  end
+  Octo.load_config config
+  connection = Cequel.connect(Octo.get_config(:cassandra))
+  Cequel::Record.connection = connection
+end
+
+# Load default tasks from Cequel
+spec = Gem::Specification.find_by_name 'cequel'
+load "#{spec.gem_dir}/lib/cequel/record/tasks.rb"
+
+# Remove those tasks from cequel which we shall override
+%w(cequel:init cequel:migrate cequel:reset).each do |t|
+  Rake.application.instance_variable_get('@tasks').delete(t)
+end
+
+# Overriding rake actions
+namespace :octo do
+
+  desc 'Create keyspace and tables for all defined models'
+  task :init => %w(cequel:keyspace:create octo:migrate)
+
+  desc 'Drop keyspace if exists, then create and migrate'
+  task :reset => :environment do
+    kong_delete
+    clear_cache
+    if Cequel::Record.connection.schema.exists?
+      task('cequel:keyspace:drop').invoke
+    end
+    task('cequel:keyspace:create').invoke
+    migrate
+  end
+
+  desc "Synchronize all models defined in `lib/octocore/models' with Cassandra " \
+       "database schema"
+  task :migrate => :environment do
+    migrate
+  end
+end
+
+# Delete Kong Consumers and Apis
+def kong_delete
+  Octo::Helpers::KongBridge.delete_all
+  puts 'Kong Cleaned'
+end
+
+# Clear Cache
+def clear_cache
+  default_cache = {
+    host: '127.0.0.1', port: 6379
+  }
+  redis = Redis.new(default_cache.merge(driver: :hiredis))
+  redis.flushall
+  puts 'Cache Cleaned'
+end
+
+def migrate
+  watch_stack = ActiveSupport::Dependencies::WatchStack.new
+
+  migration_table_names = Set[]
+
+  classes = Set[]
+
+  project_root = Dir.pwd
+  models_dir_path = "#{File.expand_path('lib/octocore/models', project_root)}/"
+  model_files = Dir.glob(File.join(models_dir_path, '**', '*.rb'))
+
+  model_files.sort.each do |file|
+    watch_namespaces = ["Object"]
+    model_file_name = file.sub(/^#{Regexp.escape(models_dir_path)}/, "")
+    dirname = File.dirname(model_file_name)
+    watch_namespaces << dirname.classify unless dirname == "."
+    watch_stack.watch_namespaces(watch_namespaces)
+
+    require_dependency(file)
+
+    new_constants = watch_stack.new_constants
+    if new_constants.empty?
+      _new = model_file_name.sub(/\.rb$/, "")
+      if Octo.constants.include?_new.classify.to_sym
+        new_constants << "Octo"
+      else
+        new_constants << "Octo"
+        #new_constants << _new.classify
+      end
+    end
+
+    new_constants.each do |class_name|
+      begin
+        clazz = class_name.constantize
+      rescue LoadError, RuntimeError, NameError => e
+        puts e
+      else
+        if clazz.is_a?(Class)
+          if clazz.ancestors.include?(Cequel::Record) &&
+              !migration_table_names.include?(clazz.table_name.to_sym)
+            clazz.synchronize_schema
+            migration_table_names << clazz.table_name.to_sym
+            puts "** Synchronized schema for #{class_name}"
+          end
+        elsif clazz.is_a?(Module)
+          method_name = :constants
+          clazzes = clazz.public_send(method_name) if clazz.respond_to? method_name
+          clazzes.each do |_clazz|
+            _cls = clazz.const_get(_clazz)
+            if _cls.is_a?(Class) and !classes.include?_cls
+              if _cls.ancestors.include?(Cequel::Record) &&
+                  !migration_table_names.include?(_cls.table_name.to_sym)
+                _cls.synchronize_schema
+                migration_table_names << _cls.table_name.to_sym
+                puts "Synchronized schema for #{_cls}"
+                classes << _cls
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/bin/fakestream

@@ -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
+
+    BASE_URL = 'http://127.0.0.1:8000'
+
+    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 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
+
+    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