sidekick-client 0.1.0

data/lib/ext/uuidtools-2.1.1/tasks/metrics.rake

@@ -0,0 +1,22 @@
+namespace :metrics do
+  task :lines do
+    lines, codelines, total_lines, total_codelines = 0, 0, 0, 0
+    for file_name in FileList["lib/**/*.rb"]
+      f = File.open(file_name)
+      while line = f.gets
+        lines += 1
+        next if line =~ /^\s*$/
+        next if line =~ /^\s*#/
+        codelines += 1
+      end
+      puts "L: #{sprintf("%4d", lines)}, " +
+        "LOC #{sprintf("%4d", codelines)} | #{file_name}"
+      total_lines     += lines
+      total_codelines += codelines
+
+      lines, codelines = 0, 0
+    end
+
+    puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
+  end
+end

data/lib/ext/uuidtools-2.1.1/tasks/rdoc.rake

@@ -0,0 +1,29 @@
+require "rake/rdoctask"
+
+namespace :doc do
+  desc "Generate RDoc documentation"
+  Rake::RDocTask.new do |rdoc|
+    rdoc.rdoc_dir = "doc"
+    rdoc.title    = "#{PKG_NAME}-#{PKG_VERSION} Documentation"
+    rdoc.options << "--line-numbers" << "--inline-source" <<
+      "--accessor" << "cattr_accessor=object" << "--charset" << "utf-8"
+    rdoc.template = "#{ENV["template"]}.rb" if ENV["template"]
+    rdoc.rdoc_files.include("README", "CHANGELOG", "LICENSE")
+    rdoc.rdoc_files.include("lib/**/*.rb")
+  end
+
+  desc "Generate ri locally for testing"
+  task :ri do
+    sh "rdoc --ri -o ri ."
+  end
+
+  desc "Remove ri products"
+  task :clobber_ri do
+    rm_r "ri" rescue nil
+  end
+end
+
+desc "Alias to doc:rdoc"
+task "doc" => "doc:rdoc"
+
+task "clobber" => ["doc:clobber_rdoc", "doc:clobber_ri"]

data/lib/ext/uuidtools-2.1.1/tasks/rubyforge.rake

@@ -0,0 +1,89 @@
+namespace :gem do
+  desc 'Package and upload to RubyForge'
+  task :release => ["gem:package"] do |t|
+    require 'rubyforge'
+
+    v = ENV['VERSION'] or abort 'Must supply VERSION=x.y.z'
+    abort "Versions don't match #{v} vs #{PROJ.version}" if v != PKG_VERSION
+    pkg = "pkg/#{GEM_SPEC.full_name}"
+
+    rf = RubyForge.new
+    rf.configure
+    puts 'Logging in...'
+    rf.login
+
+    c = rf.userconfig
+    changelog = File.open("CHANGELOG") { |file| file.read }
+    c['release_changes'] = changelog
+    c['preformatted'] = true
+
+    files = ["#{pkg}.tgz", "#{pkg}.zip", "#{pkg}.gem"]
+
+    puts "Releasing #{PKG_NAME} v. #{PKG_VERSION}"
+    rf.add_release RUBY_FORGE_PROJECT, PKG_NAME, PKG_VERSION, *files
+  end
+end
+
+namespace :doc do
+  desc "Publish RDoc to RubyForge"
+  task :release => ["doc:rdoc"] do
+    require "rake/contrib/sshpublisher"
+    require "yaml"
+
+    config = YAML.load(
+      File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+    )
+    host = "#{config['username']}@rubyforge.org"
+    remote_dir = RUBY_FORGE_PATH + "/api"
+    local_dir = "doc"
+    Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+  end
+end
+
+namespace :spec do
+  desc "Publish specdoc to RubyForge"
+  task :release => ["spec:specdoc"] do
+    require "rake/contrib/sshpublisher"
+    require "yaml"
+
+    config = YAML.load(
+      File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+    )
+    host = "#{config['username']}@rubyforge.org"
+    remote_dir = RUBY_FORGE_PATH + "/specdoc"
+    local_dir = "specdoc"
+    Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+  end
+
+  namespace :rcov do
+    desc "Publish coverage report to RubyForge"
+    task :release => ["spec:rcov"] do
+      require "rake/contrib/sshpublisher"
+      require "yaml"
+
+      config = YAML.load(
+        File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+      )
+      host = "#{config['username']}@rubyforge.org"
+      remote_dir = RUBY_FORGE_PATH + "/coverage"
+      local_dir = "coverage"
+      Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+    end
+  end
+end
+
+namespace :website do
+  desc "Publish website to RubyForge"
+  task :release => ["doc:release", "spec:release", "spec:rcov:release"] do
+    require "rake/contrib/sshpublisher"
+    require "yaml"
+
+    config = YAML.load(
+      File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+    )
+    host = "#{config['username']}@rubyforge.org"
+    remote_dir = RUBY_FORGE_PATH
+    local_dir = "website"
+    Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+  end
+end

data/lib/ext/uuidtools-2.1.1/tasks/spec.rake

@@ -0,0 +1,64 @@
+require 'spec/rake/verify_rcov'
+
+namespace :spec do
+  Spec::Rake::SpecTask.new(:rcov) do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_opts = ['--color', '--format', 'specdoc']
+    if RCOV_ENABLED
+      t.rcov = true
+    else
+      t.rcov = false
+    end
+    t.rcov_opts = [
+      '--exclude', 'spec',
+      '--exclude', '1\\.8\\/gems',
+      '--exclude', '1\\.9\\/gems',
+      '--exclude', 'addressable\\/idna\\.rb', # unicode tables too big
+    ]
+  end
+
+  Spec::Rake::SpecTask.new(:normal) do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_opts = ['--color', '--format', 'specdoc']
+    t.rcov = false
+  end
+
+  if RCOV_ENABLED
+    RCov::VerifyTask.new(:verify) do |t|
+      t.threshold = 100.0
+      t.index_html = 'coverage/index.html'
+    end
+
+    task :verify => :rcov
+  end
+
+  desc "Generate HTML Specdocs for all specs"
+  Spec::Rake::SpecTask.new(:specdoc) do |t|
+    specdoc_path = File.expand_path(
+      File.join(File.dirname(__FILE__), '../specdoc/'))
+    Dir.mkdir(specdoc_path) if !File.exist?(specdoc_path)
+
+    output_file = File.join(specdoc_path, 'index.html')
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_opts = ["--format", "\"html:#{output_file}\"", "--diff"]
+    t.fail_on_error = false
+  end
+
+  namespace :rcov do
+    desc "Browse the code coverage report."
+    task :browse => "spec:rcov" do
+      require "launchy"
+      Launchy::Browser.run("coverage/index.html")
+    end
+  end
+end
+
+if RCOV_ENABLED
+  desc "Alias to spec:verify"
+  task "spec" => "spec:verify"
+else
+  desc "Alias to spec:normal"
+  task "spec" => "spec:normal"
+end
+
+task "clobber" => ["spec:clobber_rcov"]

data/lib/ext/uuidtools-2.1.1/website/index.html

@@ -0,0 +1,95 @@
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+  <head>
+    <meta charset="utf-8"/>
+    <title>UUIDTools</title>
+    <style type="text/css">
+      * {
+        font-size: 100%;
+        margin: 0;
+        padding: 0;
+      }
+      
+      body {
+        font-family: "Lucida Grande", Verdana, sans-serif;
+        margin: 1em;
+      }
+      
+      a {
+        color: #880000;
+      }
+
+      a:visited {
+        color: #333333;
+      }
+      
+      h1 {
+        font-size: 2em;
+        margin: 0 0 0.8em 0;
+        text-align: center;
+      }
+      
+      h2 {
+        font-size: 1em;
+        margin: 0.8em 0;
+      }
+      
+      p {
+        margin: 0.8em 0;
+      }
+
+      ul {
+        font-size: 0.9em;
+        margin: 0 0 0 1.5em;
+      }
+      
+      div {
+        width: 50%;
+        margin: 0 auto;
+        padding: 0.8em;
+        background-color: #AA5852;
+        border: 2px solid #C2645D;
+      }
+
+      @media print {
+        body {
+          font-size: 0.9em;
+        }
+        
+        a {
+          text-decoration: none;
+          color: #000;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <h1>UUIDTools</h1>
+    <div>
+      <p>
+        A simple universally unique ID generation library.
+      </p>
+      <ul>
+        <li>
+          <a href="http://rubyforge.org/projects/uuidtools/">
+            Project Page
+          </a>
+        </li>
+        <li>
+          <a href="http://github.com/sporkmonger/uuidtools/tree/">
+            GitHub Page
+          </a>
+        </li>
+        <li><a href="/api/">API</a></li>
+        <li><a href="/specdoc/">Specifications</a></li>
+        <li><a href="/coverage/">Code Coverage</a></li>
+      </ul>
+      <p>
+        You know what to do:
+      </p>
+      <p>
+        <code>sudo gem install uuidtools</code>
+      </p>
+    </div>
+  </body>
+</html>

data/lib/sidekick/client/sidekick_client.rb

@@ -0,0 +1,46 @@
+require 'yaml'
+require 'logger'
+require 'eventmachine'
+require "uuidtools"
+require "#{File.dirname(__FILE__)}/../shared/sidekick_logger"
+require "#{File.dirname(__FILE__)}/../shared/sidekick_queue_publisher"
+
+Thread.new { EM.run } unless EM.reactor_running?
+
+SIDEKICK_CONFIG = "/etc/vamp/sidekick.conf" unless defined?(SIDEKICK_CONFIG)
+# TODO: this client must be used from within a rails application right now
+# because it relies on RAILS_ROOT to find its config file
+#
+class SidekickClient
+  attr_reader :logger
+  
+  def initialize(config_override={})
+    @config ||= YAML.load_file(SIDEKICK_CONFIG).with_indifferent_access.merge(config_override)
+    @logger = SidekickLogger.new(@config[:sidekick_log_file].to_s.gsub("sidekick.log","sidekick_client.log"))
+    @logger.info "Initialized SidekickClient with config #{@config.inspect}"
+    @qconn = SidekickQueuePublisher.new(@config, @logger)   
+  end    
+
+  def self.send_and_disconnect(cmd, args={}, queue_name=nil)
+    SidekickClient.new.send_and_disconnect(cmd,args,queue_name)
+  end
+  
+  def self.send_and_receive(cmd, args={}, queue_name=nil)
+    SidekickClient.new.send_and_receive(cmd,args,queue_name)
+  end
+  
+  def send_and_disconnect(cmd, args={}, queue_name=nil)
+    message = { :command => cmd, :args => args}
+    
+    @qconn.publish(message.to_yaml, queue_name || @config[:queue_name])
+    return true
+  end
+
+  def send_and_receive(cmd, args={}, queue_name=nil)
+    temp_queue = "tmp-reply-#{UUIDTools::UUID.random_create}"
+    message = { :command => cmd, :args => args, :reply_to => {:exchange => @config[:exchange], :routing_key => temp_queue}}
+    
+    response = @qconn.publish(message.to_yaml, queue_name || @config[:queue_name], temp_queue)        
+    return response && YAML.load(response)
+  end
+end

data/lib/sidekick/shared/sidekick_logger.rb

@@ -0,0 +1,14 @@
+require 'logger'
+
+class SidekickLogger < Logger
+  CONNECTION_LOSS_SLEEP_RETRY = 5
+  
+  def format_message(severity, timestamp, msg, progname) 
+    "#{timestamp.strftime("%b %d %H:%M:%S")} sidekick[#{Process.pid}] #{severity}: #{progname.to_s.gsub(/\n/, '').lstrip}\n"
+  end
+  
+  def log_connection_error_and_sleep(e)
+    self.warn %{Caught a potential RabbitMQ connection loss, or server down. Will attempt to re-initialize and sleep for #{CONNECTION_LOSS_SLEEP_RETRY} seconds, and attempt to reconnect. Exception details: #{e.class}: #{e.message} #{e.backtrace.join("\n")}}    
+    sleep(CONNECTION_LOSS_SLEEP_RETRY)    
+  end
+end

data/lib/sidekick/shared/sidekick_queue_publisher.rb

@@ -0,0 +1,91 @@
+require "bunny"
+
+class SidekickQueuePublisher
+  attr_accessor :logger
+
+  def initialize(config, logger)
+    @logger = logger
+    @config = config.with_indifferent_access
+  end
+
+  # Publish a message using a given routing key
+  # If a temp reply queue name is supplied, this method
+  # will automatically subscribe to the reply queue
+  # and block until a message is received.
+  def publish(message, routing_key, temp_reply_queue_name=nil)    
+    with_bunny_connection(temp_reply_queue_name) do |reply_queue|
+      if routing_key =~ /amq.gen/
+        logger.warn "Cannot publish messages to queues starting with amq.gen - this must have been an old request and will be dropped."
+        return true
+      else
+        logger.info "Publishing message to #{routing_key}: #{message}"      
+      end
+      
+      if reply_queue
+        response = nil
+        @b.queue(routing_key).publish(message, :persistent => true)          
+
+        msg=""
+        begin
+          Timeout::timeout(5) do
+            while true
+            	msg = reply_queue.pop
+              if msg == :queue_empty
+                # keep going
+              else
+              	logger.info "Got msg #{msg}"
+                response = msg
+                break
+              end
+            end
+          end
+        rescue Timeout::Error
+          logger.error "Timed out while waiting for response from server."
+          response = ":error: Timed out while waiting for response, messaging server may be down."        
+        end
+
+        begin
+          reply_queue.delete
+        rescue
+          logger.warn "Error deleting reply queue #{reply_queue.inspect}"
+        end
+      
+        return response
+      else
+        @b.queue(routing_key).publish(message, :persistent => true)          
+      end
+      return true
+    end
+  end
+  
+  private
+  def with_bunny_connection(temp_reply_queue_name=nil, &block)
+    begin
+      temp_queue = init_bunny_connection(temp_reply_queue_name)
+      block.call(temp_queue)
+    rescue Exception => e
+      logger.log_connection_error_and_sleep(e)  
+      init_bunny_connection
+      retry
+    ensure
+      @b.stop if @b rescue ""  # we don't care about exceptions here
+    end
+  end
+
+  def init_bunny_connection(temp_reply_queue_name=nil)
+    @broker = @config[:brokers].first              
+    logger.info "Establishing connection to RabbitMQ broker #{@broker.inspect}."          
+    @b = Bunny.new(:host => (@broker[0] || "localhost"), :port => (@broker[1] || 5672), :timeout => @config[:timeout])          
+    @b.start
+  
+    if temp_reply_queue_name
+      reply_queue  = @b.queue(temp_reply_queue_name)
+      reply_queue.bind(@b.exchange(temp_reply_queue_name), :key => temp_reply_queue_name)
+      reply_queue
+    end
+  
+  rescue Exception => e
+    logger.log_connection_error_and_sleep(e)
+    retry
+  end
+end