dynport_tools 0.2.19 → 0.2.20

data/Gemfile

@@ -21,4 +21,8 @@ group :development do
   gem "autotest-growl"
   gem "ruby-debug"
   gem "timecop"
+  gem "guard"
+  gem "growl"
+  gem "rb-fsevent"
+  gem "spork"
 end

data/Gemfile.lock

@@ -8,6 +8,9 @@ GEM
     columnize (0.3.4)
     diff-lcs (1.1.2)
     git (1.2.5)
+    growl (1.0.3)
+    guard (0.8.4)
+      thor (~> 0.14.6)
     jeweler (1.6.4)
       bundler (~> 1.0)
       git (>= 1.2.5)
@@ -17,6 +20,7 @@ GEM
     mime-types (1.16)
     nokogiri (1.5.0)
     rake (0.9.2)
+    rb-fsevent (0.4.3.1)
     rbx-require-relative (0.0.5)
     rcov (0.9.9)
     redis (2.2.1)
@@ -33,7 +37,9 @@ GEM
       ruby-debug-base (~> 0.10.4.0)
     ruby-debug-base (0.10.4)
       linecache (>= 0.3)
+    spork (0.8.5)
     term-ansicolor (1.0.5)
+    thor (0.14.6)
     timecop (0.3.5)
     typhoeus (0.2.4)
       mime-types
@@ -48,12 +54,16 @@ DEPENDENCIES
   autotest-growl
   bundler (~> 1.0.0)
   diff-lcs
+  growl
+  guard
   jeweler (~> 1.6.4)
   nokogiri
+  rb-fsevent
   rcov
   redis
   rspec (~> 2.3.0)
   ruby-debug
+  spork
   term-ansicolor
   timecop
   typhoeus

data/Guardfile

@@ -0,0 +1,104 @@
+require "guard/guard"
+
+SPORK_CONFIG = {
+  # "SPORK_INTEGRATION" => 8987,
+  # "SPORK_LIGHT" => 8988,
+  "SPORK_DEFAULT" => 8989
+}
+
+module ::Guard
+  class Multispork < ::Guard::Guard
+    def start
+      ENV["AUTOTEST"] = "true"
+      SPORK_CONFIG.each do |env_key, port|
+        Process.fork do
+          ENV[env_key] = "true"
+          cmd = "spork -p #{port}"
+          puts "running: #{cmd} with #{ENV[env_key]}=true"
+          system cmd
+        end
+      end
+    end
+  end
+end
+
+module ::Guard
+  class Simplespec < ::Guard::Guard
+    def run_all
+      puts "running all"
+    end
+
+    def run_on_change(paths)
+      paths = paths.select { |path| File.exists?(path) }.uniq
+      if paths.any?
+        started = Time.now
+        cmd = "rspec #{paths.join(" ")}"
+        port = nil
+        if paths.first.include?("spec/integration")
+          port = SPORK_CONFIG["SPORK_INTEGRATION"]
+        elsif paths.length == 1 && File.read(paths.first).match(/^# (SPORK_.*?)\n/)
+          port = SPORK_CONFIG[$1]
+        end
+        cmd << " --drb"
+        # cmd << " --drb --port #{port || SPORK_CONFIG["SPORK_DEFAULT"]} --color"
+        cmd << " --color"
+        puts "-" * 100
+        stats = run_specs(cmd)
+        # status = :success #!!out.match(/ 0 failure/) ? :success : :failed
+        diff = Time.now - started
+        puts "-" * 100
+        time_s = "#{diff} (#{diff - stats[:time]} overhead)"
+        puts "total time: #{time_s}"
+        ::Guard::Notifier.notify("#{stats[:status]} in #{time_s}", :title => "RSpec #{stats[:examples]} examples", :image => stats[:status])
+      end
+    end
+    
+    def run_specs(cmd)
+      puts "running #{cmd}"
+      chars = ""
+      IO.popen(cmd, "r") do |f|
+        until f.eof?
+          char = f.readchar.chr
+          print char
+          $stdout.flush
+          chars << char
+        end
+      end
+      { :time => chars[/Finished in ([\d|\.]+)/, 1].to_f, :examples => chars[/(\d+) examples/].to_i }.tap do |stats|
+        if !chars.include?(" 0 failures")
+          stats.merge!(:status => :failed)
+        # elsif !chars.include?(" 0 pending")
+        #   :pending
+        else
+          stats.merge!(:status => :success)
+        end
+      end
+    end
+  end
+end
+
+group "spork" do
+  guard "multispork" do
+  end
+end
+
+group "spec" do
+  guard "simplespec" do
+    watch(%r{^spec/.*_spec.rb})
+    watch(%r{^spec/.+_spec\.rb$})
+    watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+    # watch('spec/spec_helper.rb')  { "spec" }
+
+    # Rails example
+    watch(%r{^spec/.+_spec\.rb$})
+    watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+    watch(%r{^lib/(.+)\.rb$})                           { |m| "spec/lib/#{m[1]}_spec.rb" }
+    watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+    # watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+    # watch('spec/spec_helper.rb')                        { "spec" }
+    # watch('config/routes.rb')                           { "spec/routing" }
+    # watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+    # Capybara request specs
+    # watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+  end
+end

data/README.rdoc

@@ -1,6 +1,10 @@
 = dynport_tools
 
-Description goes here.
+== LogTracer ==
+  DynportTools::LogTracer.setup(Rails.logger)
+  
+  Rails.logger.register_tracer(/SELECT.*?FROM.*?users/) do |arr|
+  end
 
 == Contributing to dynport_tools
  

data/VERSION

@@ -1 +1 @@
-0.2.19
+0.2.20

data/dynport_tools.gemspec

@@ -4,14 +4,14 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{dynport_tools}
-  s.version = "0.2.19"
+  s.name = "dynport_tools"
+  s.version = "0.2.20"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tobias Schwab"]
-  s.date = %q{2011-09-14}
-  s.description = %q{Collection of various tools}
-  s.email = %q{tobias.schwab@dynport.de}
+  s.date = "2012-01-31"
+  s.description = "Collection of various tools"
+  s.email = "tobias.schwab@dynport.de"
   s.executables = ["xmldiff", "redis_dumper"]
   s.extra_rdoc_files = [
     "LICENSE.txt",
@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
     ".rspec",
     "Gemfile",
     "Gemfile.lock",
+    "Guardfile",
     "LICENSE.txt",
     "README.rdoc",
     "Rakefile",
@@ -38,24 +39,30 @@ Gem::Specification.new do |s|
     "lib/dynport_tools/differ.rb",
     "lib/dynport_tools/embedded_redis.rb",
     "lib/dynport_tools/eta.rb",
+    "lib/dynport_tools/features.rb",
     "lib/dynport_tools/have_attributes.rb",
     "lib/dynport_tools/jenkins.rb",
     "lib/dynport_tools/job_dsl.rb",
     "lib/dynport_tools/log_tracer.rb",
     "lib/dynport_tools/redis_dumper.rb",
     "lib/dynport_tools/redis_q.rb",
+    "lib/dynport_tools/services.rb",
+    "lib/dynport_tools/settings.rb",
     "lib/dynport_tools/xml_file.rb",
     "spec/dynport_tools/ascii_table_spec.rb",
     "spec/dynport_tools/deep_merger_spec.rb",
     "spec/dynport_tools/differ_spec.rb",
     "spec/dynport_tools/embedded_redis_spec.rb",
     "spec/dynport_tools/eta_spec.rb",
+    "spec/dynport_tools/features_spec.rb",
     "spec/dynport_tools/have_attributes_spec.rb",
     "spec/dynport_tools/jenkins_spec.rb",
     "spec/dynport_tools/job_dsl_spec.rb",
     "spec/dynport_tools/log_tracer_spec.rb",
     "spec/dynport_tools/redis_dumper_spec.rb",
     "spec/dynport_tools/redis_q_spec.rb",
+    "spec/dynport_tools/services_spec.rb",
+    "spec/dynport_tools/settings_spec.rb",
     "spec/dynport_tools/xml_file_spec.rb",
     "spec/dynport_tools_spec.rb",
     "spec/fixtures/file_a.xml",
@@ -63,11 +70,11 @@ Gem::Specification.new do |s|
     "spec/spec_helper.rb",
     "spec/xml_diff_spec.rb"
   ]
-  s.homepage = %q{http://github.com/tobstarr/dynport_tools}
+  s.homepage = "http://github.com/tobstarr/dynport_tools"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.6.2}
-  s.summary = %q{Collection of various tools}
+  s.rubygems_version = "1.8.11"
+  s.summary = "Collection of various tools"
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
@@ -87,6 +94,10 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<autotest-growl>, [">= 0"])
       s.add_development_dependency(%q<ruby-debug>, [">= 0"])
       s.add_development_dependency(%q<timecop>, [">= 0"])
+      s.add_development_dependency(%q<guard>, [">= 0"])
+      s.add_development_dependency(%q<growl>, [">= 0"])
+      s.add_development_dependency(%q<rb-fsevent>, [">= 0"])
+      s.add_development_dependency(%q<spork>, [">= 0"])
     else
       s.add_dependency(%q<nokogiri>, [">= 0"])
       s.add_dependency(%q<redis>, [">= 0"])
@@ -102,6 +113,10 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<autotest-growl>, [">= 0"])
       s.add_dependency(%q<ruby-debug>, [">= 0"])
       s.add_dependency(%q<timecop>, [">= 0"])
+      s.add_dependency(%q<guard>, [">= 0"])
+      s.add_dependency(%q<growl>, [">= 0"])
+      s.add_dependency(%q<rb-fsevent>, [">= 0"])
+      s.add_dependency(%q<spork>, [">= 0"])
     end
   else
     s.add_dependency(%q<nokogiri>, [">= 0"])
@@ -118,6 +133,10 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<autotest-growl>, [">= 0"])
     s.add_dependency(%q<ruby-debug>, [">= 0"])
     s.add_dependency(%q<timecop>, [">= 0"])
+    s.add_dependency(%q<guard>, [">= 0"])
+    s.add_dependency(%q<growl>, [">= 0"])
+    s.add_dependency(%q<rb-fsevent>, [">= 0"])
+    s.add_dependency(%q<spork>, [">= 0"])
   end
 end
 

data/lib/dynport_tools.rb

@@ -8,4 +8,4 @@ require "cgi"
 require "term/ansicolor"
 require "diff/lcs"
 
-%w(deep_merger differ jenkins redis_dumper xml_file have_attributes redis_q eta ascii_table embedded_redis job_dsl log_tracer).map { |m| require "dynport_tools/#{m}" }
+%w(settings features deep_merger differ jenkins redis_dumper xml_file have_attributes redis_q eta ascii_table embedded_redis job_dsl log_tracer).map { |m| require "dynport_tools/#{m}" }

data/lib/dynport_tools/features.rb

@@ -0,0 +1,24 @@
+class DynportTools::Features
+  class << self
+    attr_accessor :features, :redis
+    
+    def feature(name)
+      self.features ||= Array.new
+      self.features << name
+      self.class.send(:define_method, :"#{name}_enabled_for?") do |user, &block|
+        enabled = !user.nil? && redis.sismember("features/#{name}/users", user.id.to_s)
+        block.call if enabled && block
+        enabled
+      end
+    end
+    
+    def add_user(feature, user)
+      raise "feature #{feature} not defined" if !(features || []).include?(feature)
+      redis.sadd("features/#{feature}/users", user.id)
+    end
+    
+    def remove_user(feature, user)
+      redis.srem("features/#{feature}/users", user.id)
+    end
+  end
+end

data/lib/dynport_tools/services.rb

@@ -0,0 +1,130 @@
+class DynportTools::Services
+  DEFAULTS = {
+    :solr_url => "http://localhost:8983/solr/",
+    :solr_data_root => "/opt/solr",
+    :solr_xml => %(
+      <?xml version="1.0" encoding="UTF-8" ?>
+      <solr sharedLib="lib" persistent="true">
+        <cores adminPath="/admin/cores">
+        </cores>
+      </solr>
+    ).gsub(/^\s+/, "")
+  }
+  
+  # solr
+  attr_writer :solr_url
+  attr_accessor :solr_instance_path, :solr_data_root
+  
+  def solr_data_root
+    @solr_data_root || DEFAULTS[:solr_data_root]
+  end
+  
+  def solr_xml_path
+    "#{solr_data_root}/solr.xml"
+  end
+  
+  def solr_bootstrapped?
+    File.exists?(solr_xml_path)
+  end
+  
+  def bootstrap_solr
+    raise "#{solr_xml_path} already exists" if solr_bootstrapped?
+    write_solr_xml_when_possible
+  end
+  
+  def write_solr_xml_when_possible
+    raise "please create #{solr_data_root} first" if !File.directory?(solr_data_root)
+    write_solr_xml
+  end
+  
+  def write_solr_xml
+    File.open(solr_xml_path, "w") do |f|
+      f.puts(DEFAULTS[:solr_xml])
+    end
+  end
+  
+  def head(url)
+    if code = system_call(%(curl -s -I "#{url}" | head -n 1)).to_s.split(" ").at(1)
+      code.to_i
+    end
+  end
+  
+  def post(url)
+    system_call(%(curl -s -I -XPOST "#{url}"))
+  end
+  
+  def solr_url
+    @solr_url || DEFAULTS[:solr_url]
+  end
+  
+  def solr_running?
+    head(self.solr_url) == 200
+  end
+  
+  def solr_core_exists?(core_name)
+    head("#{solr_url}#{core_name}/admin/") == 200
+  end
+  
+  def create_solr_core(core_name)
+    raise "please set solr_instance_path first!" if self.solr_instance_path.nil?
+    raise "please set solr_data_root first!" if self.solr_data_root.nil?
+    post("#{solr_url}admin/cores?action=CREATE&name=#{core_name}&instanceDir=#{solr_instance_path}&dataDir=#{solr_data_root}/#{core_name}")
+  end
+  
+  def unload_solr_core(core_name)
+    post("#{solr_url}admin/cores?action=UNLOAD&core=#{core_name}")
+  end
+  
+  # redis
+  attr_writer :redis_path_prefix, :redis_config_path, :redis_config_hash
+  
+  def redis_running?
+    system_call(%(echo "info" | redis-cli -s #{redis_socket_path} 2> /dev/null | grep uptime_in_seconds)).include?("uptime_in_seconds")
+  end
+  
+  def redis_path_prefix
+    @redis_path_prefix or raise "redis_path_prefix not set!"
+  end
+  
+  def redis_socket_path
+    "#{redis_path_prefix}.socket"
+  end
+  
+  def redis_config_path
+    "#{redis_path_prefix}.conf"
+  end
+  
+  def redis_log_path
+    "#{redis_path_prefix}.log"
+  end
+  
+  def redis_config_hash
+    { 
+      :unixsocket => redis_socket_path, 
+      :port => 0,
+      :logfile => redis_log_path,
+      :daemonize => "yes"
+    }.merge(@redis_config_hash || {})
+  end
+  
+  def redis_config
+    (redis_config_hash || {}).map { |key, value| "#{key} #{value}" if !value.nil? }.compact.join("\n")
+  end
+  
+  def write_redis_config
+    raise "please set redis_config_path first!" if redis_config_path.nil?
+    File.open(redis_config_path, "w") do |f|
+      f.puts(redis_config)
+    end
+  end
+  
+  def start_redis
+    write_redis_config
+    system_call("redis-server #{redis_config_path}")
+  end
+  
+  def system_call(cmd)
+    puts "executing: #{cmd}"
+    Kernel.send(:`, cmd)
+  end
+end

data/lib/dynport_tools/settings.rb

@@ -0,0 +1,93 @@
+class DynportTools::Settings
+  SETTINGS_KEY = "settings"
+  SETTINGS_UPDATED_AT_KEY = "#{SETTINGS_KEY}/updated_at"
+  
+  class << self
+    attr_accessor :redis, :defaults
+
+    def set(key_or_hash, default_or_nil = nil)
+      self.defaults ||= Hash.new
+      if key_or_hash.is_a?(Hash)
+        key_or_hash.each do |key, default|
+          self.defaults[key.to_sym] = default
+          define_methods_for_key_and_default(key.to_sym, default)
+        end
+      elsif !default_or_nil.nil?
+        self.defaults[key_or_hash.to_sym] = default_or_nil
+        define_methods_for_key_and_default(key_or_hash.to_sym, default_or_nil)
+      end
+    end
+    
+    def define_methods_for_key_and_default(key, default)
+      self.class.send(:define_method, key) do
+        get(key)
+      end
+      
+      self.class.send(:define_method, :"set_#{key}") do |value|
+        set_value(key, value)
+      end
+      
+      # bool methods
+      if [true, false].include?(default)
+        self.class.send(:define_method, "#{key}?") do
+          get(key)
+        end
+        
+        self.class.send(:define_method, :"disable_#{key}!") do
+          set_value(key, false)
+        end
+        
+        self.class.send(:define_method, :"enable_#{key}!") do
+          set_value(key, true)
+        end
+      end
+    end
+    
+    def set_value(key, value)
+      time = Time.now
+      redis.multi do
+        redis.hset(SETTINGS_KEY, key, value)
+        redis.set(SETTINGS_UPDATED_AT_KEY, time.to_i)
+      end
+      reload!(time)
+    end
+    
+    def convert_value_for_key(key, value)
+      if defaults[key].is_a?(Numeric)
+        value.to_i
+      elsif [true, false].include?(defaults[key])
+        value == "true"
+      else
+        value.to_s
+      end
+    end
+    
+    def get(key)
+      if value = all[key.to_s]
+        convert_value_for_key(key, value)
+      else
+        defaults[key]
+      end
+    end
+    
+    def all
+      if @all.nil? || expired?
+        reload!
+      end
+      @all
+    end
+    
+    def reload!(timestamp = nil)
+      @all = redis.hgetall(SETTINGS_KEY) 
+      @cached_at = timestamp || Time.now
+    end
+    
+    def expired?
+      @cached_at && Time.now - @cached_at > 60
+    end
+    
+    def changed?
+      @cached_at.nil? || redis.get(SETTINGS_UPDATED_AT_KEY).to_i != @cached_at.to_i
+    end
+  end
+end