cassilds-model 0.0.2

data/lib/cassandra-model/persistence.rb

@@ -0,0 +1,280 @@
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/array/extract_options'
+module CassandraModel
+  module Persistence
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :include, InstanceMethods
+    end
+
+    module InstanceMethods
+      def save
+        raise ActiveRecord::ReadOnlyRecord if readonly?
+        return self unless valid?
+        run_callbacks :before_save
+        newrec = new_record?
+        callback = newrec ? :before_create : :before_update
+        run_callbacks callback
+        write(attributes)
+        callback = newrec ? :after_create : :after_update
+        run_callbacks callback
+        run_callbacks :after_save
+      end
+
+      def destroy
+        run_callbacks :before_destroy
+        self.class.send(:remove, key)
+        self.deleted!
+        run_callbacks :after_destroy
+      end
+
+      def reload
+        self.class.get(key)
+      end
+
+      def update_attributes(attrs)
+        self.attributes = attrs
+        save
+      end
+
+      def remove_attributes(attrs)
+        attrs.each {|attr| self.class.remove_column(key, attr) }
+      end
+
+      private
+
+      def write(attrs)
+        self.class.send(:write, key, attrs)
+        @new_record = false
+        self
+      end
+    end
+
+    module ClassMethods
+      attr_writer :write_consistency_level, :read_consistency_level
+
+      def create(attributes)
+        new(attributes).tap do |object|
+          object.save
+        end
+      end
+
+      def write_consistency_level(level)
+        @write_consistency_level = level
+      end
+
+      def read_consistency_level(level)
+        @read_consistency_level = level
+      end
+
+      def get(key, options = {})
+        find_one(key, options)
+      end
+
+      def [](key)
+        record = get(key)
+        raise RecordNotFound, "cannot find out key=`#{key}` in `#{column_family}`" unless record
+        record
+      end
+
+      def exists?(key)
+        return false if key.nil? || key == ''
+        #connection.exists?(column_family, key)
+        key = validate_key_type(key)
+        !connection.get(column_family, key).empty?
+      end
+
+      def all(*args)
+        find(:all, *args)
+      end
+
+      def first(*args)
+        find(:first, *args)
+      end
+
+      def last(*args)
+        find(:last, *args)
+      end
+
+      def find(*args)
+        options = args.extract_options!
+        validate_find_options(options)
+        # set_readonly_option!(options) Not Implemented Yet
+
+        case args.first
+        when :first then find_initial(options)
+        when :last  then find_last(options)
+        when :all   then find_every(options)
+        else             find_from_ids(args, options)
+        end
+      end
+
+      private
+
+      def write(key, attributes)
+        benchmark("CassandraModel[#{self.name}].write, key: #{key.to_s}") do
+          connection.insert(column_family, key, attrs2write(attributes),
+            :consistency => @write_consistency_level || Cassandra::Consistency::QUORUM)
+        end
+        key
+      end
+
+      def attrs2write attrs
+        res = {}
+        attrs.each do |key, item|
+          res[key] = item.kind_of?(Integer) ? Cassandra::Long.new(item).to_s : item
+        end
+        return res
+      end
+
+      def remove(key)
+        key = validate_key_type(key)
+        benchmark("CassandraModel[#{self.name}].remove, key: #{key.to_s}") do
+          connection.remove(column_family, key,
+            :consistency => @write_consistency_level || Cassandra::Consistency::QUORUM)
+        end
+      end
+
+      def remove_column(key, column)
+        key = validate_key_type(key)
+        benchmark("CassandraModel[#{self.name}].remove_column, key: #{key.to_s}, #{column.to_s}") do
+          connection.remove(column_family, key, column,
+            :consistency => @write_consistency_level || Cassandra::Consistency::QUORUM)
+        end
+      end
+
+      def init_model(key, attrs)
+        return new(attrs, false).tap do |object|
+          object.key = key
+          object.new_record = false
+          object.deleted! if attrs.empty?
+        end
+      end
+
+      def find_one(key, options)
+        key = validate_key_type(key)
+        raise RecordNotFound, "Couldn't find #{name} without an ID" if key.blank?
+        options = options || {}
+        readonly = options.delete(:readonly)
+
+        model = nil
+        benchmark("CassandraModel[#{self.name}].find_one, key: #{key.to_s}") do
+          attrs = connection.get_columns(column_family, key, columns.stringify_keys.keys, options)
+          unless attrs.empty?
+            model = init_model(key, attrs)
+            model.readonly! if readonly
+          end
+        end
+        return model
+      end
+
+      def find_initial(options)
+        options = options || {}
+        options.update(:limit => 1)
+        return find_every(options).first
+      end
+
+      def find_last(options)
+        options = options || {}
+        # in practice this does NOT work (Thrift API limitation)
+        options.update({:limit => 1, :order => :desc, :reversed => true})
+        return find_every(options).first
+      end
+
+      def find_every(options)
+        options = options || {}
+        nofilter = options.delete(:no_filter)
+        readonly = options.delete(:readonly)
+        keyrange = options[:keyrange]
+        keyrange = ''..'' if keyrange.blank?
+
+        records = []
+        benchmark("CassandraModel[#{self.name}].find_every, keyrange: #{keyrange.to_s}") do
+          results = connection.get_range_columns(column_family, columns.stringify_keys.keys,
+            :start => keyrange.first, :finish => keyrange.last, :count => (options[:limit] || 100))
+          
+          (results || {}).each { |key, columns|
+            model = init_model(key, columns)
+            model.readonly! if readonly
+            records.push(model) unless nofilter && model.deleted?
+          }
+        end
+        return records
+      end
+
+      def find_from_ids(ids, options)
+        if ids.first.kind_of?(Range)
+          find_range(ids.first, options)
+        else
+          expects_array = ids.first.kind_of?(Array)
+          return ids.first if expects_array && ids.first.empty?
+
+          ids = ids.flatten.compact.uniq
+
+          case ids.size
+          when 0
+            raise RecordNotFound, "Couldn't find #{name} without an ID"
+          when 1
+            result = find_one(ids.first, options)
+            expects_array ? [ result ] : result
+          else
+            find_some(ids, options)
+          end
+        end
+      end
+
+      def find_range(ids, options)
+        options = options || {}
+        options.update({:keyrange => ids})
+        find_every(options)
+      end
+
+      def find_some(ids, options)
+        options = options || {}
+        result = find_every(options)
+
+        # Determine expected size from limit and offset, not just ids.size.
+        expected_size =
+          if options[:limit] && ids.size > options[:limit]
+          options[:limit]
+        else
+          ids.size
+        end
+
+        # 11 ids with limit 3, offset 9 should give 2 results.
+        if options[:offset] && (ids.size - options[:offset] < expected_size)
+          expected_size = ids.size - options[:offset]
+        end
+
+        if result.size == expected_size
+          result
+        else
+          raise RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids.inspect}) (found #{result.size} results, but was looking for #{expected_size})"
+        end
+      end
+
+      VALID_FIND_OPTIONS = [ :select, :keyrange, :conditions, :limit, :offset,
+        :order, :readonly ]
+
+      def validate_find_options(options) #:nodoc:
+        options.assert_valid_keys(VALID_FIND_OPTIONS)
+      end
+      
+      def validate_key_type(key)
+        if !self.key_type.blank? and self.key_type.downcase == 'time_uuid'
+          key = SimpleUUID::UUID.new(key)
+        end
+        return key.to_s
+      end
+
+      #      def first(keyrange = ''..'', options = {})
+      #        all(keyrange, options.merge(:limit => 1)).first
+      #      end
+
+      #      def last(keyrange = ''..'', options = {})
+      #        all(keyrange, options.merge({:reversed => true, :limit => 1})).first
+      #      end
+
+    end
+  end
+end

data/lib/cassandra-model/railtie.rb

@@ -0,0 +1,15 @@
+require 'cassandra-model/config'
+module CassandraModel
+  if defined? Rails::Railtie
+    require 'rails'
+    class Railtie < Rails::Railtie
+      initializer 'cassandra-model.config_init' do
+        CassandraModel::Config.initialize
+      end
+      rake_tasks do
+        load "tasks/paperclip.rake"
+      end
+    end
+  end
+
+end

data/lib/cassandra-model/types.rb

@@ -0,0 +1,61 @@
+module CassandraModel
+  class StringType
+    def self.dump(v)
+      v && v
+    end
+
+    def self.load(v)
+      v && v.to_s
+    end
+  end
+
+  class IntegerType
+    def self.dump(v)
+      v && v.to_i
+    end
+
+    def self.load(v)
+      v && Cassandra::Long.new(v).to_i
+    end
+  end
+
+  class FloatType
+    def self.dump(v)
+      v && v.to_s
+    end
+
+    def self.load(v)
+      v && v.to_f
+    end
+  end
+
+  class DatetimeType
+    def self.dump(v)
+      !v.blank? && v.strftime('%FT%T%z')
+    end
+
+    def self.load(v)
+      !v.blank? && ::DateTime.strptime(v, '%FT%T%z')
+    end
+  end
+
+  class JsonType
+    def self.dump(v)
+      v && ::JSON.dump(v)
+    end
+
+    def self.load(v)
+      v && ::JSON.load(v)
+    end
+  end
+
+  class BooleanType
+    def self.dump(v)
+      v == '1'
+    end
+
+    def self.load(v)
+      v ? '1' : '0'
+    end
+  end
+end

data/lib/cassandra-model/version.rb

@@ -0,0 +1,3 @@
+class CassandraModel
+  VERSION = '0.0.2'
+end

data/lib/cassandra-model.rb

@@ -0,0 +1,30 @@
+require 'cassandra/0.7'
+require 'forwardable'
+require 'date'
+
+$:.unshift(File.dirname(__FILE__))
+
+module CassandraModel
+  class CassandraModelError < StandardError;       end
+  class UnknownRecord       < CassandraModelError; end
+  class InvalidRecord       < CassandraModelError; end
+  class RecordNotFound      < CassandraModelError; end
+end
+
+unless Object.respond_to? :tap
+  class Object
+    def tap(value)
+      yield(value)
+      value
+    end
+  end
+end
+
+require 'cassandra-model/types'
+require 'active_support/callbacks'
+require 'cassandra-model/config'
+require 'cassandra-model/connection'
+require 'cassandra-model/persistence'
+require 'cassandra-model/batches'
+require 'cassandra-model/base'
+#require 'cassandra-model/railtie'

data/test/base_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class CassandraModelCallbacksTest < Test::Unit::TestCase
+  context "CassandraModel::Base" do
+    setup do
+      @klass = Class.new(CassandraModel::Base) do
+        key :name
+        column :age, :integer
+        column :dob, :datetime
+        column :note, :json
+
+        validate do
+          self.errors << "dob required" if dob.nil?
+        end
+      end
+
+      @klass.establish_connection 'cassandra-model'
+    end
+
+    should "connect to cassandra" do
+      assert_kind_of Cassandra, @klass.connection
+    end
+
+    should "store all defined columns" do
+      assert_equal({:age  => :integer ,
+                    :dob  => :datetime,
+                    :note => :json}   , @klass.columns)
+    end
+
+    should "validate model by provided block" do
+      assert_kind_of Proc, @klass.validation
+
+      model = @klass.new()
+      assert !model.valid?
+
+      model = @klass.new(:name => "tl")
+      assert !model.valid?
+
+      model = @klass.new(:name => "tl", :dob => DateTime.now)
+      assert model.valid?
+      assert_equal "tl", model.key
+      assert_kind_of DateTime, model.dob
+    end
+  end
+end

data/test/callbacks_test.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class CassandraModelCallbacksTest < Test::Unit::TestCase
+  context "CassandraModel::Callbacks" do
+    setup do
+      @base  = Class.new(Object) do
+        include CassandraModel::Callbacks
+        define_callbacks :foo
+      end
+
+      @klass = Class.new(@base) do
+        def bar; @n = [:bar]; end
+
+        def foo
+          run_callbacks(:foo) { @n << :foo }
+        end
+
+        def baz(v)
+          @n << :baz if v == [:bar, :foo]
+        end
+
+        def quux; @n << :quux; end
+      end
+    end
+
+    should "provide before and after callbacks for foo function" do
+      assert @klass.respond_to?(:define_callbacks)
+      assert @klass.respond_to?(:callbacks)
+      assert @klass.respond_to?(:before_foo)
+      assert @klass.respond_to?(:after_foo)
+      assert_equal Hash.new, @klass.callbacks
+    end
+
+    should "invoke callback functions when foo executed" do
+      @klass.send(:before_foo, :bar)
+      @klass.send(:after_foo, :baz, :quux)
+      assert_equal 2, @klass.callbacks.length
+      assert_equal [:bar], @klass.callbacks[:before_foo]
+      assert_equal [:baz, :quux], @klass.callbacks[:after_foo]
+      assert_equal [:bar, :foo, :baz, :quux], @klass.new.foo
+    end
+  end
+end

data/test/cassandra_model_test.rb

@@ -0,0 +1,84 @@
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class User < CassandraModel::Base
+  column_family :Users
+
+  key :username
+  column :full_name
+  column :created_at, :datetime
+
+  write_consistency_level Cassandra::Consistency::ALL
+
+  before_save :set_default_time
+
+  validate do
+    errors << "full name required" if full_name.nil? || full_name.empty?
+  end
+
+private
+
+  def set_default_time
+    self.created_at = Time.now
+  end
+end
+
+class CassandraModelTest < Test::Unit::TestCase
+  context "CassandraModel" do
+    setup do
+      @connection = CassandraModel::Base.establish_connection("CassandraModel")
+      @connection.clear_keyspace!
+
+      @user = User.create(:username => "tl", :full_name => "tien le")
+    end
+
+    should "be able to connect to Cassandra" do
+      assert_kind_of Cassandra, @connection
+      assert_equal "CassandraModel", @connection.keyspace
+    end
+
+    should "not create a new user when validation fails" do
+      user = User.create(:username => "tl")
+      assert !user.valid?
+      assert user.new_record?
+
+      user = User.new(:username => "tl").save
+      assert user.new_record?
+      assert_equal "full name required", user.errors.first
+
+      user = User.new(:full_name => "tl").save
+      assert_equal "key required", user.errors.first
+    end
+
+    should "create a new user when validation passed" do
+      assert !@user.new_record?
+      assert @user.eql?(User.get("tl"))
+      assert_equal @user, User.get("tl")
+      assert_equal "tien le", User.get("tl").full_name
+
+      user = User.new(:username => "abc", :full_name => "Foo")
+      user.save
+      assert_equal ["created_at", "full_name"], @connection.get(:Users, "abc").keys
+    end
+
+    should "destroy a record" do
+      @user.destroy
+      assert User.get("tl").nil?
+      assert User.get(nil).nil?
+
+      assert_raise(CassandraModel::RecordNotFound) { User["tl"] }
+      assert_raise(CassandraModel::RecordNotFound) { User[nil] }
+    end
+
+    should "return true if record exists and otherwise" do
+      assert User.exists?("tl")
+      assert !User.exists?("foo")
+    end
+
+    should "only take defined attributes" do
+      user = User.new(:username => "abc", :full_name => "Foo", :hachiko => 'dog')
+      user.save
+      assert_equal ["created_at", "full_name"], @connection.get(:Users, "abc").keys
+    end
+  end
+end

data/test/config/cassandra.in.sh

@@ -0,0 +1,47 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# The directory where Cassandra's configs live (required)
+CASSANDRA_CONF=$CASSANDRA_CONF
+
+# This can be the path to a jar file, or a directory containing the 
+# compiled classes. NOTE: This isn't needed by the startup script,
+# it's just used here in constructing the classpath.
+cassandra_bin=$CASSANDRA_HOME/build/classes
+
+# The java classpath (required)
+CLASSPATH=$CASSANDRA_CONF:$CASSANDRA_BIN
+
+for jar in $CASSANDRA_HOME/lib/*.jar $CASSANDRA_HOME/build/lib/jars/*.jar; do
+    CLASSPATH=$CLASSPATH:$jar
+done
+
+# Arguments to pass to the JVM
+JVM_OPTS=" \
+        -ea \
+        -Xms128M \
+        -Xmx1G \
+        -XX:TargetSurvivorRatio=90 \
+        -XX:+AggressiveOpts \
+        -XX:+UseParNewGC \
+        -XX:+UseConcMarkSweepGC \
+        -XX:+CMSParallelRemarkEnabled \
+        -XX:+HeapDumpOnOutOfMemoryError \
+        -XX:SurvivorRatio=128 \
+        -XX:MaxTenuringThreshold=0 \
+        -Dcom.sun.management.jmxremote.port=8080 \
+        -Dcom.sun.management.jmxremote.ssl=false \
+        -Dcom.sun.management.jmxremote.authenticate=false"

data/test/config/log4j-tools.properties

@@ -0,0 +1,27 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# for production, you should probably set the root to INFO
+# and the pattern to %c instead of %l.  (%l is slower.)
+
+# output messages into a rolling log file as well as stdout
+log4j.rootLogger=WARN,stderr
+
+# stderr
+log4j.appender.stderr=org.apache.log4j.ConsoleAppender
+log4j.appender.stderr.target=System.err
+log4j.appender.stderr.layout=org.apache.log4j.PatternLayout
+log4j.appender.stderr.layout.ConversionPattern=%5p %d{HH:mm:ss,SSS} %m%n

data/test/config/log4j.properties

@@ -0,0 +1,40 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# for production, you should probably set the root to INFO
+# and the pattern to %c instead of %l.  (%l is slower.)
+
+# output messages into a rolling log file as well as stdout
+log4j.rootLogger=INFO,stdout,R
+
+# stdout
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%5p %d{HH:mm:ss,SSS} %m%n
+
+# rolling log file
+log4j.appender.R=org.apache.log4j.RollingFileAppender
+log4j.appender.file.maxFileSize=20MB
+log4j.appender.file.maxBackupIndex=50
+log4j.appender.R.layout=org.apache.log4j.PatternLayout
+log4j.appender.R.layout.ConversionPattern=%5p [%t] %d{ISO8601} %F (line %L) %m%n
+# Edit the next line to point to your logs directory
+log4j.appender.R.File=data/logs/system.log
+
+# Application logging options
+#log4j.logger.com.facebook=DEBUG
+#log4j.logger.com.facebook.infrastructure.gms=DEBUG
+#log4j.logger.com.facebook.infrastructure.db=DEBUG