cassandra_datum 0.0.9

data/.gitignore

@@ -0,0 +1,52 @@
+.idea
+atlassian*
+
+# rcov generated
+coverage
+coverage.data
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+
+# For TextMate
+#*.tmproj
+#tmtags
+
+# For emacs:
+#*~
+#\#*
+#.\#*
+
+# For vim:
+#*.swp
+
+# For redcar:
+#.redcar
+
+# For rubinius:
+#*.rbc

data/Gemfile

@@ -0,0 +1,20 @@
+source "http://rubygems.org"
+
+gem 'activesupport', '~> 3'
+gem 'activemodel', '~> 3'
+gem 'activerecord', '~> 3'
+gem 'exception_helper'
+
+gem "cassandra", :git => "http://github.com/backupify/cassandra.git"
+gem 'active_attr', :git => "http://github.com/backupify/active_attr.git"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda"
+  gem 'factory_girl'
+  gem "rdoc"
+  gem "bundler"
+  gem "jeweler"
+  gem "thin"
+end

data/Gemfile.lock

@@ -0,0 +1,113 @@
+GIT
+  remote: http://github.com/backupify/active_attr.git
+  revision: 69951a36e62bc348b6d2c86ce50c1251ad709e34
+  specs:
+    active_attr (0.8.2)
+      activemodel (>= 3.0.2, < 4.1)
+      activesupport (>= 3.0.2, < 4.1)
+
+GIT
+  remote: http://github.com/backupify/cassandra.git
+  revision: e66c55ebb61422db96546f2052c5701f6e8e5343
+  specs:
+    cassandra (0.12.2)
+      json
+      rake
+      simple_uuid (~> 0.2.0)
+      thrift_client (>= 0.7.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.14)
+      activesupport (= 3.2.14)
+      builder (~> 3.0.0)
+    activerecord (3.2.14)
+      activemodel (= 3.2.14)
+      activesupport (= 3.2.14)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.14)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    addressable (2.3.5)
+    arel (3.0.2)
+    builder (3.0.4)
+    daemons (1.1.9)
+    eventmachine (1.0.3)
+    exception_helper (0.1.2)
+    factory_girl (4.2.0)
+      activesupport (>= 3.0.0)
+    faraday (0.8.8)
+      multipart-post (~> 1.2.0)
+    git (1.2.6)
+    github_api (0.10.1)
+      addressable
+      faraday (~> 0.8.1)
+      hashie (>= 1.2)
+      multi_json (~> 1.4)
+      nokogiri (~> 1.5.2)
+      oauth2
+    hashie (2.0.5)
+    highline (1.6.19)
+    httpauth (0.2.0)
+    i18n (0.6.5)
+    jeweler (1.8.7)
+      builder
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      github_api (= 0.10.1)
+      highline (>= 1.6.15)
+      nokogiri (= 1.5.10)
+      rake
+      rdoc
+    json (1.8.0)
+    jwt (0.1.8)
+      multi_json (>= 1.5)
+    multi_json (1.7.9)
+    multi_xml (0.5.5)
+    multipart-post (1.2.0)
+    nokogiri (1.5.10)
+    oauth2 (0.9.2)
+      faraday (~> 0.8)
+      httpauth (~> 0.2)
+      jwt (~> 0.1.4)
+      multi_json (~> 1.0)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    rake (10.1.0)
+    rdoc (4.0.1)
+      json (~> 1.4)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.1.5)
+    shoulda-matchers (2.3.0)
+      activesupport (>= 3.0.0)
+    simple_uuid (0.2.0)
+    thin (1.5.1)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    thrift (0.9.1)
+    thrift_client (0.9.2)
+      thrift (~> 0.9.0)
+    tzinfo (0.3.37)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  active_attr!
+  activemodel (~> 3)
+  activerecord (~> 3)
+  activesupport (~> 3)
+  bundler
+  cassandra!
+  exception_helper
+  factory_girl
+  jeweler
+  rdoc
+  shoulda
+  thin

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Jason Haruska
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,14 @@
+= cassandra_datum
+
+== Test setup
+
+Do this in cassandra-cli:
+
+  use BackupifyMetadata_test; # create it first if it doesn't exist
+  create column family MockCassandraData with column_type='Super' and comparator='com.backupify.db.DatumType' and subcomparator='UTF8Type';
+
+== Copyright
+
+Copyright (c) 2012 Jason Haruska. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'bundler'
+require "bundler/gem_tasks"
+require 'rake'
+require 'rake/testtask'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test
+

data/cassandra_datum.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cassandra_datum/version'
+
+
+Gem::Specification.new do |gem|
+  gem.name = "cassandra_datum"
+  gem.version = CassandraDatum::VERSION
+  gem.authors = ["Jason Haruska"]
+  gem.email = ["jason@backupify.com"]
+  gem.description = "Cassandra backed ORM"
+  gem.summary = "An active record like object base that is backed by Cassandra"
+  gem.homepage = "http://github.com/backupify/cassandra_datum"
+  gem.license = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency(%q<activesupport>, [">= 2.3.5"])
+  gem.add_runtime_dependency(%q<activemodel>, [">= 2.3.5"])
+  gem.add_runtime_dependency(%q<activerecord>, [">= 2.3.5"])
+  gem.add_runtime_dependency(%q<cassandra>, [">= 0"])
+  gem.add_runtime_dependency(%q<active_attr>, [">= 0"])
+  gem.add_runtime_dependency(%q<exception_helper>, [">= 0"])
+
+  gem.add_development_dependency(%q<shoulda>, [">= 0"])
+  gem.add_development_dependency(%q<factory_girl>, [">= 0"])
+end
+

data/lib/cassandra_datum.rb

@@ -0,0 +1,19 @@
+require 'cassandra_datum/version'
+require 'cassandra_datum/base'
+require 'cassandra_datum/railtie' if defined?(Rails)
+
+module CassandraDatum
+
+  def self.configuration
+    @@configuration ||= begin
+      require 'erb'
+      env = defined?(Rails) ? Rails.env : 'development'
+      config_file = ENV['CONFIG_FILE'] || (defined?(Rails) ? "#{Rails.root}/config/cassandra.yml" : nil)
+      fail "No CONFIG_FILE or Rails.root defined" unless config_file
+      config_file = File.expand_path(config_file)
+      config = YAML::load(ERB.new(IO.read(config_file)).result)
+      config[env]
+    end
+  end
+
+end

data/lib/cassandra_datum/base.rb

@@ -0,0 +1,272 @@
+require 'active_attr/model'
+require 'active_model/observing'
+require 'active_model/callbacks'
+require 'exception_helper/retry'
+require 'active_record/errors'
+require 'active_record/validations'
+require 'cassandra'
+
+module CassandraDatum
+class Base
+  include ActiveAttr::Model
+
+  include ActiveModel::Observing
+  extend ActiveModel::Callbacks
+
+  include ExceptionHelper::Retry
+
+  define_model_callbacks :save
+  define_model_callbacks :destroy
+
+  attr_reader :updated_at
+
+  FIRST_KEY = ''
+  LAST_KEY = 'a~0'
+  DEFAULT_ALL_COUNT = 50
+  DEFAULT_WALK_ROW_COUNT = 1000
+  SINGLETON = 1
+
+  before_save :populate_type_if_exists
+
+  def initialize_with_updated_at(*attr)
+    # the OrderedHash returned by the cassandra client has a timestamps method which contains the write date of each column
+    if attr.size > 0 && attr.first.respond_to?(:timestamps)
+      timestamp_in_microseconds = attr.first.timestamps.values.max
+      @updated_at = Time.at(timestamp_in_microseconds / 1000000, timestamp_in_microseconds % 1000000).to_datetime
+    end
+
+    initialize_without_updated_at(*attr)
+  end
+
+  def initialize_with_utf8_encoding(*attr)
+    if attr.size > 0 && attr.first.is_a?(Hash)
+      #careful not to trounce timestamps in Cassandra::OrderedHash
+      timestamps = attr.first.is_a?(Cassandra::OrderedHash) ? attr.first.timestamps : nil
+      attr.first.each { |k, v| attr.first[k] = "#{v}".force_encoding('UTF-8') unless v.blank? }
+      attr.first.instance_variable_set(:@timestamps, timestamps) if timestamps.present?
+    end
+
+    initialize_without_utf8_encoding(*attr)
+  end
+
+  alias_method_chain :initialize, :updated_at
+  alias_method_chain :initialize, :utf8_encoding
+
+  def self.create(*attr)
+    new(*attr).tap(&:save!)
+  end
+
+  @@column_family = nil
+
+  def self.column_family(*name)
+    if name.present?
+      @@column_family = name.first
+    else
+      @@column_family || model_name.plural.camelize
+    end
+  end
+
+  #key can be from to_param as well as just the key. This function handles both
+  def self.find(key)
+    row_id, column_name = Base64.decode64(key.tr('-_', '+/')).split(':', 2)
+
+    res = cassandra_client.get(column_family, row_id, column_name)
+
+    raise ActiveRecord::RecordNotFound.new if res.blank?
+
+    initialize_datum res
+  end
+
+  def self.find_by_key(key)
+    find(key)
+  rescue ActiveRecord::RecordNotFound
+    nil
+  end
+
+  #will always return data in reverse chronological order
+  # @option[row_id] the row_id to paginate through (optional if passing in a before_id or after_id)
+  # @option[before_id] return a page of data that occurs before this key (exclusive)
+  # @option[after_id] return a page of data that occurs after this key (exclusive)
+  # @option[count] limit the number of data returned (default 50)
+  def self.all(options={})
+    options.symbolize_keys! if options.respond_to?(:symbolize_keys!)
+
+    cass_options = {}
+    cass_options[:count] = (options[:count] || DEFAULT_ALL_COUNT).to_i
+
+    if options[:before_id]
+      row_id, cass_options[:start] = Base64.decode64(options[:before_id].tr('-_', '+/')).split(':', 2)
+      cass_options[:reversed] = true
+      cass_options[:count] += 1
+    elsif options[:after_id]
+      row_id, cass_options[:start] = Base64.decode64(options[:after_id].tr('-_', '+/')).split(':', 2)
+      cass_options[:count] += 1
+    elsif options[:row_id]
+      row_id = options[:row_id].to_s
+    end
+
+    result = cassandra_client.get(column_family, row_id, cass_options).collect do |k, v|
+      initialize_datum v
+    end
+
+    if options[:before_id]
+      result.delete_at(0) if result.size > 0 && result[0].key == options[:before_id]
+      result.reverse!
+    elsif options[:after_id]
+      result.delete_at(0) if result.size > 0 && result[0].key == options[:after_id]
+    end
+
+    result
+  end
+
+  # don't overuse this.  it crawls an entire row
+  def self.find_each(row_id, options = {})
+    walk_row(row_id, options) do |k, v|
+      yield initialize_datum(v)
+    end
+  end
+
+  # don't overuse this.  it crawls an entire row
+  def self.find_each_key(row_id, options = {})
+    walk_row(row_id, options) { |k, v| yield Base64.strict_encode64([row_id, k].join(':')).tr('+/', '-_') }
+  end
+
+  def row_id
+    SINGLETON.to_s
+  end
+
+  def document_id
+    SINGLETON
+  end
+
+  def timestamp
+    Time.at(SINGLETON).to_datetime
+  end
+
+  def column_name
+    encode_for_cassandra("#{document_id}~#{timestamp.to_i}")
+  end
+
+  def key
+    Base64.strict_encode64([row_id, column_name].join(':')).tr('+/', '-_')
+  end
+
+  def encode_for_cassandra(str, opts = {})
+    CassandraDatum::Base.encode_for_cassandra(str, opts)
+  end
+
+  def self.encode_for_cassandra(str, opts = {})
+    encode_opts = {
+        :invalid => :replace,
+        :undef => :replace,
+        :replace => ''
+    }.merge(opts)
+
+    str.encode('UTF-8', encode_opts).force_encoding('ASCII-8BIT')
+  end
+
+
+  def to_param
+    self.key
+  end
+
+  def save
+    save!
+  rescue Exception => e
+    false
+  end
+
+  def save!
+    _run_save_callbacks do
+      attrs = {}
+
+      attributes.reject { |k, v| v.nil? }.each do |k, v|
+        attrs[k] = [Array, Hash].any?{ |collection_class| v.is_a?(collection_class) } ? v.to_json : "#{v}"
+        attrs[k] = encode_for_cassandra(attrs[k])
+      end
+
+      raise ActiveRecord::RecordInvalid.new(self) unless self.valid?
+
+      self.class.cassandra_client.insert(self.class.column_family, self.row_id, {self.column_name => attrs})
+
+      # this value might be a tad different from the value in cassandra.  the only way to get the true updated_at value is to reload the datum
+      @updated_at = DateTime.now
+    end
+  end
+
+  def reload
+    self.class.find(self.key)
+  end
+
+  def destroy
+    _run_destroy_callbacks { self.delete }
+  end
+
+  def self.delete_all(row_id)
+    cassandra_client.remove column_family, row_id
+  end
+
+  def self.delete(row_id, *column_names)
+    column_names.flatten.each { |column_name| CASSANDRA_CLIENT.remove column_family, row_id, column_name }
+  end
+
+  def delete
+    self.class.delete(self.row_id, self.column_name)
+  end
+
+  def self.cassandra_client
+    if defined?(::CASSANDRA_CLIENT)
+      ::CASSANDRA_CLIENT
+    else
+      logger.error("No cassandra client defined. Please set CASSANDRA_CLIENT")
+      nil
+    end
+  end
+
+
+  def as_json(options={})
+    options = {:only => self.class.accessor_names}.merge(options)
+    self.include_root_in_json = false
+    super(options)
+  end
+
+  def new_record?
+    self.updated_at.blank?
+  end
+
+  protected
+
+  # don't overuse this.  it crawls an entire row
+  def self.walk_row(row_id, options = {})
+    options = {:count => DEFAULT_WALK_ROW_COUNT}.merge(options)
+
+    start = options[:start] || (options[:reversed] ? LAST_KEY : FIRST_KEY)
+    last_start = nil
+
+    loop do
+      retry_on_failure(::Thrift::Exception, :retry_count => 5, :retry_sleep => 10) do
+        last_start = start
+
+        res = cassandra_client.get(column_family, row_id, options.merge(:start => start))
+
+        res.each do |k, v|
+          next if k == last_start # ignore the first result we get back.  since start is the last record in the previous get, it'll always be off by 1
+          start = k
+          yield [k, v]
+        end
+      end
+
+      break if last_start == start
+    end
+  end
+
+  def populate_type_if_exists
+    self.type = self.class.name if self.respond_to?(:type=)
+  end
+
+  def self.initialize_datum(res)
+    datum_class = res['type'].present? ? res['type'].constantize : self
+    datum_class.new res
+  end
+end
+end