stat-count-client 0.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in stat-count-client.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,14 @@
+PATH
+  remote: .
+  specs:
+    stat-count-client (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+
+PLATFORMS
+  x86-mingw32
+
+DEPENDENCIES
+  stat-count-client!

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 TODO: Write your name
+
+MIT License
+
+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.md

@@ -0,0 +1,29 @@
+# Stat::Count::Client
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'stat-count-client'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stat-count-client
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/config_loader.rb

@@ -0,0 +1,18 @@
+#encoding: UTF-8
+
+#Example
+#stat.count:
+#  hessian.domain: http://localhost:8080/stat-count-runtime/hessian/remoteSimpleCountCollecter
+#  hessian.java.package:  com.ximalaya.stat.count.data
+#  log.file: D:/log/stat/stat-count-ruby.log
+#  log.level: info
+
+module ConfigLoader
+  begin
+    LOADER = YAML.load_file("../config/stat-count-client.yaml");
+    CONFIG = LOADER['stat.count']
+  rescue => err
+      CONFIG = {}
+      puts "can't load config file stat-count-client.yaml, you need to init statcountclient with config hash"
+  end
+end

data/lib/hessian_data_utils.rb

@@ -0,0 +1,40 @@
+#encoding: UTF-8
+
+module Hessian
+   module Data
+       module Utils
+         def to_hash_unit
+           hash = {}
+           instance_variables.each {|var| hash[var.to_s.delete("@")] = instance_variable_get(var) }
+           hash
+         end
+
+         def to_hash_map
+           hash = {}
+           instance_variables.each {|var|
+             internal_hash = {}
+             map = instance_variable_get(var)
+             map.each { |key, list|
+               newList = nil
+               list.each { |unit|
+                 if (newList.nil?)
+                   newList = Array.new
+                 end
+                 newList << unit.to_hessian
+               }
+               internal_hash[key] = newList
+             }
+             hash[var.to_s.delete("@")] = internal_hash
+           }
+           hash
+         end
+
+         def java_class_name(java_package)
+           index =  self.class.name.rindex "::"
+           index = (index.nil?) ?  0 : index+2
+           simple_name = self.class.name[index..-1]
+           java_package.nil? ? simple_name : java_package + "." + simple_name
+         end
+       end
+  end
+end

data/lib/logger_factory.rb

@@ -0,0 +1,37 @@
+#encoding: UTF-8
+
+require "logger"
+require "config_loader"
+require "monitor"
+
+class LoggerFactory
+    include ConfigLoader
+    @@logger = nil
+    def self.getLogger(name, log_path=nil, log_level=nil)
+       if @@logger.nil?
+         @monitor = Monitor.new
+         @monitor.synchronize do
+           if @@logger.nil?
+             if(log_path.nil?)
+               log_path = CONFIG['log.file.'+name];
+               if(log_path.nil?)
+                 log_path = "../log"
+               end
+             end
+
+              if log_level.nil?
+                log_level = CONFIG['log.level.'+name]
+                if(log_level.nil?)
+                  log_level = "error";
+                end
+              end
+
+             logger = Logger.new(log_path,'daily')
+             logger.level = Logger::const_get(log_level.upcase)
+             @@logger = logger;
+           end
+         end
+       end
+       @@logger
+    end
+end

data/lib/stat-count-client.rb

@@ -0,0 +1,335 @@
+#encoding: UTF-8
+
+require "stat-count-client/version"
+require "yaml"
+require "config_loader"
+require "logger_factory"
+require "singleton"
+require "hessian_data_utils"
+
+
+module Stat
+  module Count
+    module Data
+      class QueryUnit
+        include Hessian::Data::Utils
+        include ConfigLoader
+
+        attr :id, true
+        attr :limit, true
+
+        def to_hash
+            to_hash_unit
+        end
+
+        def to_hessian
+          Hessian2::TypeWrapper.new(java_class_name("com.ximalaya.stat.count.data"), to_hash)
+        end
+      end
+
+      class CountUnit
+        include Hessian::Data::Utils
+        include ConfigLoader
+
+        attr :id, true
+        attr :count, true
+
+        def to_hash
+            to_hash_unit
+        end
+
+        def to_hessian
+          Hessian2::TypeWrapper.new(java_class_name("com.ximalaya.stat.count.data"), to_hash)
+        end
+      end
+
+      class DateQueryUnit < QueryUnit
+        attr :fromDate, true
+        attr :toDate, true
+      end
+
+      class DateCountUnit < CountUnit
+        attr :date, true
+
+        def to_hessian
+          Hessian2::TypeWrapper.new(java_class_name("com.ximalaya.stat.count.data"), to_hash)
+        end
+      end
+
+      class SimpleCount
+        include Hessian::Data::Utils
+        include ConfigLoader
+
+        attr_accessor :counts
+
+        def initialize
+          @counts = Hash.new
+        end
+
+        def addCount(name, id, count=1, countUnit=nil)
+          countUnitList = @counts[name]
+          if (countUnitList.nil?)
+            countUnitList = Array.new
+            @counts[name] = countUnitList
+          end
+
+          if (countUnit.nil?)
+            countUnit = CountUnit.new
+          end
+          countUnit.id = id
+          countUnit.count = count
+          countUnitList << countUnit
+          self
+        end
+
+        def getCounts
+          @counts
+        end
+
+        def getCountsSize
+          @counts.length
+        end
+
+        def to_hash
+          to_hash_map
+        end
+
+        def to_hessian
+            Hessian2::TypeWrapper.new(java_class_name("com.ximalaya.stat.count.data"), to_hash)
+        end
+      end
+
+      class DateCount < SimpleCount
+        def addCountWithDate(name, id, count=1, date=Time.now)
+          dateCountUnit = DateCountUnit.new
+          dateCountUnit.date = date
+          addCount(name, id, count, dateCountUnit)
+          self
+        end
+
+        def to_hessian
+          Hessian2::TypeWrapper.new(java_class_name("com.ximalaya.stat.count.data"), to_hash)
+        end
+      end
+
+      class SimpleCountQuery
+        include Hessian::Data::Utils
+        include ConfigLoader
+
+        attr_accessor :queries
+
+        def initialize
+          @queries = Hash.new
+        end
+
+        def addQuery(name, id, limit=1, queryUnit=nil)
+          queryUnitList = @queries[name]
+
+          if(queryUnitList.nil?)
+            queryUnitList = Array.new
+            @queries[name] = queryUnitList
+          end
+
+          if(queryUnit.nil?)
+            queryUnit = QueryUnit.new
+          end
+
+          queryUnit.id = id
+          queryUnit.limit = limit
+          queryUnitList << queryUnit
+          self
+        end
+
+        def getQueries
+          @queries
+        end
+
+        def to_hash
+            to_hash_map
+        end
+
+        def to_hessian
+          Hessian2::TypeWrapper.new(java_class_name("com.ximalaya.stat.count.data"), to_hash)
+        end
+      end
+
+      class DateCountQuery < SimpleCountQuery
+        def addQueryWithDate(name, id, fromDate, toDate, limit=1)
+          queryUnit = DateQueryUnit.new
+          addQuery(name, id, limit, queryUnit)
+          self
+        end
+
+        def to_hessian
+          Hessian2::TypeWrapper.new(java_class_name("com.ximalaya.stat.count.data"), to_hash)
+        end
+      end
+
+      class CountResult
+        attr_accessor :countResults
+
+        def initialize(hash)
+          @countResults = hash['countResults']
+        end
+
+        def getResult(name=nil, id=nil)
+          if(name.nil?)
+             return @countResults
+          end
+
+          countHash = @countResults[name]
+          if(countHash.nil?)
+            raise ArgumentError,"服务的名称: " + name + " 不存在!"
+          end
+
+          if (id.nil?)
+            return countHash
+          end
+
+          count = countHash[id]
+          if(count.nil?)
+            railse ArgumentError,"业务ID: "+id +" 不存在"
+          end
+          count
+        end
+      end
+
+  end
+
+  module Client
+    class StatCountClient
+      include Stat::Count::Data
+      include ConfigLoader
+
+      def initialize(config={})
+        @hessian_url = config['hessian.domain'];
+        if (@hessian_url.nil?)
+          @hessian_url ||= ENV['stat.count.domain']
+          @hessian_url ||= CONFIG['hessian.domain']
+        end
+        @logger = LoggerFactory.getLogger("StatCountClient", config['log.file.StatCountClient'], config['log.level.StatCountClient'])
+
+        init(@hessian_url)
+      end
+
+      def incrByCountWithDate(dateCount)
+        wrapper = dateCount.to_hessian
+        @client.incrByCountWithDate(wrapper)
+      end
+
+      def incrByCount(count)
+         wrapper = count.to_hessian
+         countResult = @client.incrByCount(wrapper)
+         CountResult.new(countResult)
+      end
+
+      def incr(name, id, count=1, date=nil)
+        if(date.nil?)
+          @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)
+        wrapper = count.to_hessian
+        count_result = @client.decrByCount(wrapper)
+        CountResult.new(count_result)
+      end
+
+      def decrByCountWithDate(dateCount)
+        wrapper = dateCount.to_hessian
+        @client.decrByCountWithDate(wrapper)
+      end
+
+      def setByCountWithDate(dateCount)
+        wrapper = dateCount.to_hessian
+        @client.setByCountWithDate(wrapper)
+      end
+
+      def setByCount(count)
+        wrapper = count.to_hessian
+        @client.setByCount(wrapper)
+      end
+
+      def  set(name,id, value, date=nil)
+        if(date.nil?)
+          @client.set(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)
+        wrapper = query.to_hessian
+        countResult = @client.getByQuery(wrapper)
+        CountResult.new(countResult)
+    end
+
+    def getByDateQuery(dateQuery)
+       wrapper = dateQuery.to_hessian
+       countResult = @client.getByDateQuery(wrapper)
+       CountResult.new(countResult)
+    end
+
+      def delByQuery(query)
+       wrapper = query.to_hessian
+       @client.delByQuery(wrapper)
+      end
+
+      def delByDateQuery(dateQuery)
+        wrapper = dateQuery.to_hessian
+        @client.delByDateQuery(wrapper)
+      end
+
+      def getHello
+        @client.getHello()
+      end
+
+      def getHello1
+        @client.getHello1()
+      end
+
+      private
+      def init(hessian_url)
+        if(hessian_url.nil?)
+          raise ArgumentError.new("hessian url is null or empty")
+        end
+
+        @logger.info("Init Stat count client connect to hessian url: #{hessian_url}")
+        begin
+          @client = Hessian2::HessianClient.new(@hessian_url)
+        rescue => err
+          @logger.error("init hessian service fails!", err)
+          raise err
+        end
+      end
+
+    end
+  end
+end
+end

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

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

data/stat-count-client.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require "rake"
+require File.expand_path('../lib/stat-count-client/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["gavin"]
+  gem.email         = ["gavin@ximalya.com"]
+  gem.description   = %q{ruby client for stat count server}
+  gem.summary       = %q{stat count client}
+  gem.homepage      = "http://www.ximalaya.com"
+  gem.platform      =  Gem::Platform::RUBY
+  gem.files         =  Dir['[A-Z]*'] + Dir['test/**/*'] + Dir['lib/**/*']
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "stat-count-client"
+  gem.require_paths = ["lib", "test"]
+  gem.version       = Stat::Count::Client::VERSION
+
+  gem.add_dependency  "hessian2"
+end

data/test/count_mother.rb

@@ -0,0 +1,80 @@
+#encoding: UTF-8
+
+require "rubygems"
+require "stat-count-client"
+
+class CountMother
+  include Stat::Count::Data
+
+  def self.createIncrCount
+     SimpleCount.new.addCount("test", "1", 1).addCount("test", "1", 2).addCount("testHour", "2", 4).addCount("testDay", "3", 8)
+  end
+
+  def self.createIncrCountWithDate
+    dateCount = DateCount.new
+    now = Time.new
+
+    1.upto(5) do |j|
+       0.upto(9) do |i|
+         now_second = Time.now.to_i
+         time = now - 60* 60 * i
+         dateCount.addCountWithDate("testHour", j.to_s, j, time)
+       end
+    end
+
+    1.upto(5) do |j|
+      0.upto(9) do |i|
+        now_second = Time.now.to_i
+        time = now - 86400 * i
+        dateCount.addCountWithDate("testDay", j.to_s, j, time);
+      end
+    end
+
+    dateCount
+  end
+
+  def self.createDecrCountWithDate
+     dateCount = DateCount.new
+     now = Time.new
+
+    1.upto(5)  do |j|
+      0.upto(9) do |i|
+        count.addCount("testHour", j.to_s, 1, Time.now - i.day)
+      end
+    end
+
+     1.upto(5) do |j|
+       0.upto(9) do |i|
+         count.addCount("testDay", j.to_s, j, Time.now - i.day);
+       end
+     end
+  end
+
+  def self.initCount
+    SimpleCount.new.addCount("test", "1", 10).addCount("test", "1", 10).addCount("testHour", "2", 10).addCount("testDay", "3", 10)
+  end
+
+   def self.createDecrCount
+     SimpleCount.new.addCount("test", "1", 4).addCount("test", "1", 5).addCount("testHour", "2", 8).addCount("testDay", "3", 7)
+   end
+
+  def  self.createCountQuery
+    SimpleCountQuery.new.addQuery("test", "1").addQuery("testHour", "2").addQuery("testDay", "3")
+  end
+
+  def self.createCountQueryWithDate
+    countQuery = SimpleCountQuery.new
+
+    1.upto(5) do |i|
+      countQuery.addQuery("testHour", i.to_s, 10)
+    end
+
+    1.upto(5) do |i|
+      countQuery.addQuery "testDay", i.to_s, 10
+    end
+
+    countQuery
+  end
+
+
+end

data/test/stat_ccount_client_test.rb

@@ -0,0 +1,192 @@
+#encoding: UTF-8
+
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+$:.unshift File.join(File.dirname(__FILE__),"..")
+
+require "rubygems"
+require "hessian2"
+require "stat-count-client"
+require_relative  "count_mother"
+require "test/unit"
+
+class TC_StatCountClientTest < Test::Unit::TestCase
+  include Stat::Count::Client
+  # 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
+  end
+
+  # Called after every test method runs. Can be used to tear
+  # down fixture information.
+
+  def teardown
+    # Do nothing
+  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 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()
+  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 assertCorrect(countResult)
+    count = countResult.getResult("test", "1")
+    assert_equal(3, count)
+
+    count = countResult.getResult("testHour", "2")
+    assert_equal(4, count)
+
+    count = countResult.getResult("testDay", "3")
+    assert_equal(8, count)
+  end
+
+  def assertIncrCorrectWithDate(countResult)
+    resultMap = countResult.getResult("testHour")
+
+    resultMap.each { |key, value|
+        id_val = key.to_i
+        assert_equal(id_val * 10, value)
+    }
+
+    resultMap = countResult.getResult("testDay");
+
+    resultMap.each { |key, value|
+       id_val = key.to_i
+       assert_equal(id_val * 10, value)
+    }
+  end
+
+   def assertDecrCorrectWithDate(countResult)
+     resultMap = countResult.getResult("testHour")
+     resultMap.each { |key, value|
+       id_val = new Integer(key)
+       assert_equal(id_val * 10 - 10, value)
+     }
+
+     resultMap = countResult.getResult("testDay")
+     resultMap.each {  |key, value|
+        id_val = new Integer(key)
+       assert_equal(id_val * 10 - 10 ,value)
+     }
+   end
+
+   def assertDecrCorrect(countResult)
+     count = countResult.getResult("test", "1")
+     assert_equal(1, count)
+
+     count = countResult.getResult("testHour", "2")
+     assert_equal(2, count)
+
+     count = countResult.getResult("testDay", "3")
+     assert_equal(3, count)
+   end
+
+   def assertInitCorrect(countResult)
+     count = countResult.getResult("test", "1")
+     assert_equal(10, count)
+
+     count = countResult.getResult("testHour", "2")
+     assert_equal(10, count)
+
+     count = countResult.getResult("testDay", "3")
+     assert_equal(10, count);
+   end
+
+  def assertDel(countResult)
+    count = countResult.getResult("test", "1")
+    assert_equal(0, count)
+
+    count = countResult.getResult("testHour", "2")
+    assert_equal(0, count)
+
+    count = countResult.getResult("testDay", "3")
+    assert_equal(0, count);
+  end
+end

data/test/test.rb

@@ -0,0 +1,18 @@
+require "rubygems"
+require "hessian2"
+require "stat-count-client"
+
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+class Test
+  include Stat::Count::Data
+  def testHessian
+   count = SimpleCount.new
+   count = Test.new
+   index =  count.class.name.rindex "::"
+   index = (index.nil?) ?  0 : index+2
+   puts count.class.name[index..-1]
+  end
+end
+test = Test.new
+test.testHessian

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: stat-count-client
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- gavin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hessian2
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ruby client for stat count server
+email:
+- gavin@ximalya.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- Rakefile
+- README.md
+- stat-count-client.gemspec
+- test/count_mother.rb
+- test/stat_ccount_client_test.rb
+- test/test.rb
+- lib/config_loader.rb
+- lib/hessian_data_utils.rb
+- lib/logger_factory.rb
+- lib/stat-count-client/version.rb
+- lib/stat-count-client.rb
+homepage: http://www.ximalaya.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- test
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: stat count client
+test_files:
+- test/count_mother.rb
+- test/stat_ccount_client_test.rb
+- test/test.rb