stat-count-client 0.0.1 → 0.0.2

data/lib/stat-count-client/thrift_client.rb

@@ -0,0 +1,263 @@
+#encoding: UTF-8
+
+require "thrift_client"
+require "stat-count-client/thrift/collecter_types"
+require "stat-count-client/thrift/remote_simple_count_collecter"
+require "stat-count-client/stat_count_data"
+require "stat-count-client/logger_factory"
+require "singleton"
+
+module Stat
+    module Count
+      module Client
+        class ThriftStatCountClient
+          include ConfigLoader
+          include Stat::Count::Thrift
+          @@logger = LoggerFactory.getLogger("StatCountThriftClient")
+
+          def initialize(servers=nil, config=nil)
+            servers ||= ENV['stat.count.domain'] ||  ConfigLoader::CONFIG['thrift.domain'] || "localhost:9090"             
+            config ||= ConfigLoader::CONFIG['thrift.config']
+            if config.nil?
+              config[:client_class] = RemoteSimpleCountCollecter::Client
+              config[:application_exception_classes] = DataCollectionException
+            else
+               client_class = config['client_class'] || "RemoteSimpleCountCollecter::Client"
+               config[:client_class] = eval(client_class)
+               application_exception_classes_strs = config['application_exception_classes'] || ["DataCollectionException"]
+               application_exception_classe=application_exception_classes_strs.collect { |class_str|
+                  eval(class_str)
+               }
+               config[:application_exception_classes] = application_exception_classe
+               init(servers, config)
+            end
+          end
+
+
+          def incrByCountWithDate(date_count)
+            thrift_date_count = to_date_count(date_count)
+            @client.incrByCountWithDate(thrift_date_count)
+          end
+
+          def incrByCount(count)
+            thrift_count = to_count(count)
+            count_result_hash = @client.incrByCount(thrift_count).countResults
+            count_result_hash = {}.tap{|hash|hash['countResults'] = count_result_hash}
+            Stat::Count::Data::CountResult.new(count_result_hash)
+          end
+
+          def incr(name, id, count=1, date=nil)
+            if(date.nil?)
+              count_result_hash = @client.incrBy(name,id, count)
+            else
+              @client.incrByWithDate(name, id, count, date)
+            end
+          end
+
+          def decr(name, id, count=1, date=nil)
+             if(date.nil?)
+               @client.decrBy(name, id, count)
+             else
+               @client.decrByWithDate(name, id, count, date)
+             end
+          end
+
+          def decrByCount(count)
+            thrift_count = to_count(count)
+            count_result_hash = @client.decrByCount(thrift_count).countResults
+            count_result_hash = {}.tap{|hash|hash['countResults'] = count_result_hash}
+            Stat::Count::Data::CountResult.new(count_result_hash)
+          end
+
+          def decrByCountWithDate(dateCount)
+            thrift_date_count = to_date_count(dateCount)
+            count_result_hash = @client.decrByCountWithDate(thrift_date_count).countResults
+            count_result_hash = {}.tap{|hash|hash['countResults'] = count_result_hash}
+            Stat::Count::Data::CountResult.new(count_result_hash)
+          end
+
+          def setByCountWithDate(dateCount)
+            thrift_date_count = to_date_count(dateCount)
+            @client.setByCountWithDate(thrift_date_count)
+          end
+
+          def setByCount(count)
+            thrift_count = to_count(count)
+            @client.setByCount(thrift_count)
+          end
+
+          def set(name,id, value, date=nil)
+            if(date.nil?)
+              @client.setValue(name, id, value) 
+            else
+              @client.setWithDate(name,id, value,date)
+            end
+          end
+
+          def reset(name, id, limit=1)
+            @client.resetByLimit(name, id, limit)
+          end
+
+          def get(name, id, limit=1)
+            @client.getByLimit(name, id, limit)
+          end
+
+          def getByNames(name, id, limit=1)
+            @client.getByNamesAndLimit(name, id, limit)
+          end
+
+          def getByIds(name, ids, limit=1)
+            @client.getByIdsAndLimit(name, ids, limit)
+          end
+
+          def getByQuery(query)
+            thrift_query = to_query(query)
+            count_result_hash = @client.getByQuery(thrift_query).countResults
+            count_result_hash = {}.tap{|hash|hash['countResults'] = count_result_hash}
+            Stat::Count::Data::CountResult.new(count_result_hash)
+          end
+
+          def getByDateQuery(dateQuery)
+            thrift_query = to_date_query(query)
+            count_result_hash = @client.getByDateQuery(thrift_query).countResults
+            count_result_hash = {}.tap{|hash|hash['countResults'] = count_result_hash}
+            Stat::Count::Data::CountResult.new(count_result_hash)
+          end
+
+          def delByQuery(query)
+            thrift_query = to_query(query)
+            @client.delByQuery(thrift_query)
+          end
+
+          def delByDateQuery(dateQuery)
+            thrift_query = to_query(query)
+            @client.delByDateQuery(thrift_query)
+          end
+
+
+          private
+           def init(servers, config)
+                @@logger.info("Init Stat count client connect to thrift url: #{servers}, config: #{config}")
+                puts servers
+                puts config
+                begin
+                  @client = ThriftClient.new(servers, config)
+
+                  @client.add_callback(:on_exception) { |method_name, e|
+                    @@logger.error("call #{method_name} fails! cause by: #{e.message}, " + "\n" + e.backtrace.join("\n"))
+                    raise e
+                  }
+                rescue => e
+                  @@logger.error("init thrift client fails! cause by: #{e.message}, " +  "\n" + e.backtrace.join("\n"))
+                  raise e
+                end
+           end
+
+           def to_date_count(date_count) 
+             if date_count.nil?
+                raise ArgumentError,"DateCount is nil"
+             end
+             thrift_counts = {}
+             counts = date_count.counts
+             counts.each_pair do |key, value|
+                name = key
+                count_unit_list = value
+                thrift_unit_list = count_unit_list.map do |count_unit|
+                    thrift_count_unit = DateCountUnit.new
+                    thrift_count_unit.id = count_unit.id
+                    thrift_count_unit.count = count_unit.count
+                    thrift_count_unit.timeMills = count_unit.date.to_f*1000
+                    thrift_count_unit
+                end
+                thrift_counts[name] = thrift_unit_list
+             end
+             thrift_count = DateCount.new
+             thrift_count.counts = thrift_counts
+             thrift_count
+           end
+
+           def to_count(count) 
+             if count.nil?
+                raise ArgumentError,"Count is nil"
+             end
+             thrift_counts = {}
+             counts = count.counts
+             counts.each_pair do |key, value|
+                name = key
+                count_unit_list = value
+                thrift_unit_list = count_unit_list.map do |count_unit|
+                    thrift_count_unit = CountUnit.new
+                    thrift_count_unit.id = count_unit.id
+                    thrift_count_unit.count = count_unit.count
+                    thrift_count_unit
+                end
+                thrift_counts[name] = thrift_unit_list
+             end
+             thrift_count = SimpleCount.new
+             thrift_count.counts = thrift_counts
+             thrift_count
+           end
+
+           def to_date_query(date_query)
+             if date_query.nil?
+                raise ArgumentError,"DateQuery is nil"
+             end
+             thrift_queries = {}
+             queries = date_query.queries
+             queries.each_pair do |key, value|
+                name = key
+                query_unit_list = value
+                thrift_unit_list = query_unit_list.collect do |query_unit|
+                    thrift_query_unit = QueryDateUnit.new
+                    thrift_query_unit.id = query_unit.id
+                    thrift_count_unit.limit = query_unit.limit
+                    fromDate = query_unit.fromDate
+                    toDate = query_unit.toDate
+                    if(toDate.nil?)
+                        #not set fromDate and toDate, keep it -1,
+                        #and it will transfered to null at stat count server side 
+                        thrift_count_unit.fromDate = -1
+                        thrift_count_unit.toDate = -1
+                    else
+                        if(fromDate.nil?) 
+                            thrift_count_unit.fromDate = 0
+                        elsif(toDate >= fromDate)
+                            thrift_count_unit.fromDate = fromDate.to_f * 1000
+                            thrift_count_unit.toDate = toDate.to_f * 1000
+                        else
+                            raise ArgumentError, "fromDate is less than toDate"
+                        end
+                    end
+                end
+                thrift_queries[name] = thrift_unit_list
+             end
+             thrift_query = DateCountQuery.new
+             thrift_query.queries = thrift_queries
+             thrift_query
+           end
+
+           def to_query(query)
+             if query.nil?
+                raise ArgumentError,"CountQuery is nil"
+             end
+             thrift_queries = {}
+             queries = query.queries
+             queries.each_pair do |key, value|
+                name = key
+                query_unit_list = value
+                thrift_unit_list = query_unit_list.map do |query_unit|
+                    thrift_query_unit = QueryUnit.new
+                    thrift_query_unit.id = query_unit.id
+                    thrift_query_unit.limit = query_unit.limit
+                    thrift_query_unit
+                end
+                thrift_queries[name] = thrift_unit_list
+             end
+             thrift_query = SimpleCountQuery.new
+             thrift_query.queries = thrift_queries
+             thrift_query
+           end
+      end
+    end
+  end
+end

data/lib/stat-count-client/version.rb

@@ -1,7 +1,7 @@
 module Stat
   module Count
     module Client
-      VERSION = "0.0.1"
+      VERSION = "0.0.2"
     end
   end
 end

data/test/stat_ccount_client_test.rb

@@ -14,8 +14,7 @@ class TC_StatCountClientTest < Test::Unit::TestCase
   # Called before every test method runs. Can be used
   # to set up fixture information.
   def setup
-    @client = StatCountClient.new({'hessian.domain'=>'http://localhost:8080/stat-count-runtime/hessian/remoteSimpleCountCollecter', 'log.file.StatCountClient'=>'D:/log/stat/stat-count-ruby.log'});
-    puts @client
+    @client = StatCountClient.new();
   end
 
   # Called after every test method runs. Can be used to tear
@@ -26,95 +25,85 @@ class TC_StatCountClientTest < Test::Unit::TestCase
   end
 
   # Fake test
-  #def test_incr
-  #  @client.set("testDay", "1", 1)
-  #  value = @client.incr("testDay", "1", 2)
-  #  assert_equal(3, value)
-  #end
-  #
-  #def test_incrByCount
-  #  reset()
-  #  count = CountMother.createIncrCount
-  #  countResult = @client.incrByCount(count)
-  #  puts countResult.getResult()
-  #  assertCorrect(countResult)
-  #end
-  #
-  #def test_incrByCountWithDate
-  #  resetWithDate()
-  #  dateCount = CountMother.createIncrCountWithDate
-  #  @client.incrByCountWithDate(dateCount)
-  #  dateQuery = CountMother.createCountQueryWithDate
-  #  countResult = @client.getByQuery(dateQuery)
-  #  assertIncrCorrectWithDate(countResult)
-  #end
+  def test_incr
+    @client.set("testDay", "1", 1)
+    value = @client.incr("testDay", "1", 2)
+    assert_equal(3, value)
+  end
+
+  def test_incrByCount
+    reset()
+    count = CountMother.createIncrCount
+    countResult = @client.incrByCount(count)
+    puts countResult.getResult()
+    assertCorrect(countResult)
+  end
+
+  def test_incrByCountWithDate
+    resetWithDate()
+    dateCount = CountMother.createIncrCountWithDate
+    @client.incrByCountWithDate(dateCount)
+    dateQuery = CountMother.createCountQueryWithDate
+    countResult = @client.getByQuery(dateQuery)
+    assertIncrCorrectWithDate(countResult)
+  end
 
   def testDecr
-    #@client.set("user.tracks.count", "1", 0)
-    #begin
-    # val = @client.decr("user.tracks.count", "1", 7)
-    # assert_equal(0,val)
-    #rescue => err
-    #  puts err
-    #end
-    #
-    #getVal = @client.get("user.tracks.count", "1")
-    #assert_equal(0,getVal)
-
-    puts @client.getHello()
-    puts @client.getHello1()
+    @client.set("test", "1", 10)
+    val = @client.decr("test", "1", 7)
+    assert_equal(3,val)
+  end
+
+  def testDecrByCount
+    count = CountMother.initCount
+    @client.setByCount(count)
+    count = CountMother.createDecrCount
+    countResult = @client.decrByCount(count)
+    assertDecrCorrect(countResult)
+    reset()
+  end
+
+  def test_set
+    @client.reset("test", "1")
+    @client.set("test", "1", 100000000000000000)
+    val = @client.get("test", "1");
+    assert_equal(100000000000000000, val)
   end
 
-  #def testDecrByCount
-  #  count = CountMother.initCount
-  #  @client.setByCount(count)
-  #  count = CountMother.createDecrCount
-  #  countResult = @client.decrByCount(count)
-  #  assertDecrCorrect(countResult)
-  #  reset()
-  #end
-  #
-  #def test_set
-  #  @client.reset("test", "1")
-  #  @client.set("test", "1", 100000000000000000)
-  #  val = @client.get("test", "1");
-  #  assert_equal(100000000000000000, val)
-  #end
-  #
-  #def test_setByCount
-  #  reset()
-  #  count = CountMother.initCount
-  #  @client.setByCount(count)
-  #  query = CountMother.createCountQuery();
-  #  countResult = @client.getByQuery(query)
-  #   assertInitCorrect(countResult)
-  #end
-  #
-  #def test_del
-  #    count = CountMother.initCount
-  #    @client.setByCount(count)
-  #    query = CountMother.createCountQuery()
-  #    @client.delByQuery(query)
-  #    countResult = @client.getByQuery(query)
-  #    assertDel(countResult)
-  #end
-  #
-  #private
-  #def resetWithDate
-  #  1.upto(5) do |i|
-  #    @client.reset("testHour", i.to_s, 10)
-  #  end
-  #
-  #  1.upto(5) do |i|
-  #    @client.reset "testDay", i.to_s, 10
-  #  end
-  #end
-  #
-  #def reset
-  #  @client.reset("test", "1")
-  #  @client.reset("testHour", "2")
-  #  @client.reset("testDay", "3")
-  #end
+  def test_setByCount
+    reset()
+    count = CountMother.initCount
+    @client.setByCount(count)
+    query = CountMother.createCountQuery();
+    countResult = @client.getByQuery(query)
+     assertInitCorrect(countResult)
+  end
+
+  def test_del
+      count = CountMother.initCount
+      @client.setByCount(count)
+      query = CountMother.createCountQuery()
+      @client.delByQuery(query)
+      countResult = @client.getByQuery(query)
+      assertDel(countResult)
+  end
+
+  private
+  def resetWithDate
+    1.upto(5) do |i|
+      @client.reset("testHour", i.to_s, 10)
+    end
+
+    1.upto(5) do |i|
+      @client.reset "testDay", i.to_s, 10
+    end
+  end
+
+  def reset
+    @client.reset("test", "1")
+    @client.reset("testHour", "2")
+    @client.reset("testDay", "3")
+  end
 
   def assertCorrect(countResult)
     count = countResult.getResult("test", "1")