dummer 0.3.0

data/lib/dummer/setting.rb

@@ -0,0 +1,16 @@
+module Dummer
+  class Setting
+    attr_accessor :rate, :output, :labeled, :delimiter, :fields, :workers, :message, :input
+
+    def initialize
+      @rate = 500
+      @output = STDOUT
+      @labeled = true
+      @delimiter = "\t"
+      @fields = nil
+      @workers = 1
+      @message = "time:2013-11-25 00:23:52 +0900\tlevel:ERROR\tmethod:POST\turi:/api/v1/people\treqtime:3.1983877060667103\n"
+      @input = nil
+    end
+  end
+end

data/lib/dummer/version.rb

@@ -0,0 +1,3 @@
+module Dummer
+  VERSION = "0.3.0"
+end

data/lib/dummer/worker.rb

@@ -0,0 +1,60 @@
+require 'serverengine'
+
+module Dummer
+  module Worker
+    BIN_NUM = 10
+
+    def initialize
+      reload
+    end
+
+    def reload
+      @generator = Generator.new(config[:setting])
+      @rate = config[:setting].rate
+
+      output = config[:setting].output
+      if output.respond_to?(:write) and output.respond_to?(:close)
+        @output = output
+      else
+        @output = open(output, (File::WRONLY | File::APPEND | File::CREAT))
+        @output.sync = true
+      end
+    end
+
+    def run
+      batch_num    = (@rate / BIN_NUM).to_i
+      residual_num = (@rate % BIN_NUM)
+      while !@stop
+        current_time = Time.now.to_i
+        BIN_NUM.times do
+          break unless (!@stop && Time.now.to_i <= current_time)
+          wait(0.1) { write(batch_num) }
+        end
+        write(residual_num)
+        # wait for next second
+        while !@stop && Time.now.to_i <= current_time
+          sleep 0.01
+        end
+      end
+    ensure
+      @output.close
+    end
+
+    def stop
+      @stop = true
+    end
+
+private
+
+    def write(num)
+      num.times { @output.write @generator.generate }
+    end
+
+    def wait(time)
+      start_time = Time.now
+      yield
+      sleep_time = time - (Time.now - start_time)
+      sleep sleep_time if sleep_time > 0
+    end
+  end
+end

data/lib/ext/hash/except.rb

@@ -0,0 +1,15 @@
+class Hash
+  # Return a hash that includes everything but the given keys. This is useful for
+  # limiting a set of parameters to everything but a few known toggles:
+  #
+  #   @person.update(params[:person].except(:admin))
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  # Replaces the hash without the given keys.
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+end

data/lib/ext/hash/keys.rb

@@ -0,0 +1,138 @@
+class Hash
+  # Return a new hash with all keys converted using the block operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.transform_keys{ |key| key.to_s.upcase }
+  #  # => {"NAME"=>"Rob", "AGE"=>"28"}
+  def transform_keys
+    result = {}
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Destructively convert all keys using the block operations.
+  # Same as transform_keys but modifies +self+.
+  def transform_keys!
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   # => {"name"=>"Rob", "age"=>"28"}
+  def stringify_keys
+    transform_keys{ |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    transform_keys!{ |key| key.to_s }
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   # => {"name"=>"Rob", "age"=>"28"}
+  def symbolize_keys
+    transform_keys{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options,  :symbolize_keys
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    transform_keys!{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options!, :symbolize_keys!
+
+  # Validate all keys in a hash match <tt>*valid_keys</tt>, raising ArgumentError
+  # on a mismatch. Note that keys are NOT treated indifferently, meaning if you
+  # use strings for keys but assert symbols as keys, this will fail.
+  #
+  #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: years"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: name"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |k|
+      raise ArgumentError.new("Unknown key: #{k}") unless valid_keys.include?(k)
+    end
+  end
+
+  # Return a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  def deep_transform_keys(&block)
+    result = {}
+    each do |key, value|
+      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
+    end
+    result
+  end
+
+  # Destructively convert all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  def deep_transform_keys!(&block)
+    keys.each do |key|
+      value = delete(key)
+      self[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys!(&block) : value
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_stringify_keys
+  #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+  def deep_stringify_keys
+    deep_transform_keys{ |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  def deep_stringify_keys!
+    deep_transform_keys!{ |key| key.to_s }
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+. This includes the keys from the root hash
+  # and from all nested hashes.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+  def deep_symbolize_keys
+    deep_transform_keys{ |key| key.to_sym rescue key }
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. This includes the keys from the root hash and from all
+  # nested hashes.
+  def deep_symbolize_keys!
+    deep_transform_keys!{ |key| key.to_sym rescue key }
+  end
+end

data/lib/ext/hash/slice.rb

@@ -0,0 +1,42 @@
+class Hash
+  # Slice a hash to include only the given keys. This is useful for
+  # limiting an options hash to valid keys before passing to a method:
+  #
+  #   def search(criteria = {})
+  #     criteria.assert_valid_keys(:mass, :velocity, :time)
+  #   end
+  #
+  #   search(options.slice(:mass, :velocity, :time))
+  #
+  # If you have an array of keys you want to limit to, you should splat them:
+  #
+  #   valid_keys = [:mass, :velocity, :time]
+  #   search(options.slice(*valid_keys))
+  def slice(*keys)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    keys.each_with_object(self.class.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
+  end
+
+  # Replaces the hash with only the given keys.
+  # Returns a hash containing the removed key/value pairs.
+  #
+  #   { a: 1, b: 2, c: 3, d: 4 }.slice!(:a, :b)
+  #   # => {:c=>3, :d=>4}
+  def slice!(*keys)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    omit = slice(*self.keys - keys)
+    hash = slice(*keys)
+    hash.default      = default
+    hash.default_proc = default_proc if default_proc
+    replace(hash)
+    omit
+  end
+
+  # Removes and returns the key/value pairs matching the given keys.
+  #
+  #   { a: 1, b: 2, c: 3, d: 4 }.extract!(:a, :b) # => {:a=>1, :b=>2}
+  #   { a: 1, b: 2 }.extract!(:a, :x)             # => {:a=>1}
+  def extract!(*keys)
+    keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
+  end
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: dummer
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- sonots
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: serverengine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Generates dummy log data for Fluentd benchmark
+email:
+- sonots@gmail.com
+executables:
+- dummer
+- dummer_simple
+- dummer_yes
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/dummer
+- bin/dummer_simple
+- bin/dummer_yes
+- dummer.gemspec
+- example/input.conf
+- example/input.txt
+- example/message.conf
+- example/sample.conf
+- lib/dummer.rb
+- lib/dummer/cli.rb
+- lib/dummer/dsl.rb
+- lib/dummer/error.rb
+- lib/dummer/generator.rb
+- lib/dummer/setting.rb
+- lib/dummer/version.rb
+- lib/dummer/worker.rb
+- lib/ext/hash/except.rb
+- lib/ext/hash/keys.rb
+- lib/ext/hash/slice.rb
+homepage: https://github.com/sonots/dummer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Generates dummy log data for Fluentd benchmark
+test_files: []