haproxyctl 0.0.1

data/lib/haproxyctl/version.rb

@@ -0,0 +1,3 @@
+module HAProxyCTL
+  VERSION = "0.0.1"
+end

data/rhapr/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/rhapr/.rspec

@@ -0,0 +1 @@
+-cfs

data/rhapr/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in rhapr.gemspec
+gemspec

data/rhapr/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/gem_tasks'
+
+require 'rspec'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+task :release => :spec
+
+desc 'Run Specs'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern    = 'spec/**/*_spec.rb'
+  spec.verbose    = true
+  spec.rspec_opts = ['--color']
+end

data/rhapr/lib/rhapr.rb

@@ -0,0 +1,6 @@
+require 'rhapr/version'
+require 'rhapr/environment'
+
+module Rhapr
+  autoload :Interface, 'rhapr/interface'
+end

data/rhapr/lib/rhapr/environment.rb

@@ -0,0 +1,99 @@
+require 'socket'
+
+module Rhapr
+  module Environment
+    attr_reader :haproxy_pid, :config_path, :config, :exec, :socket_path
+
+    # @return [String, nil] The path to the HAProxy configuration file, or nil if not found. Set the ENV variable $HAPROXY_CONFIG to override defaults.
+    def config_path
+      return(@config_path) if @config_path
+
+      if ENV['HAPROXY_CONFIG']
+        @config_path = ENV['HAPROXY_CONFIG']
+      else
+        config_paths = %w{/etc/haproxy/haproxy.cfg /etc/haproxy.cfg /usr/local/etc/haproxy.cfg}
+        config_paths.select!{|cfg| File.exists?(cfg)}
+
+        @config_path = config_paths.first
+      end
+
+      return(@config_path)
+    end
+
+    # @return [String] The raw contents of the HAProxy configuration file.
+    # @raise [RuntimeError] If it cannot read the contents of #config_path.
+    def config
+      @config ||= begin
+                    File.read(config_path)
+                  rescue Errno::ENOENT => e
+                    raise RuntimeError.new("Error openning file '#{config_path}'. Exception from File.read: #{e.exception}")
+                  end
+    end
+
+    # @return [true, false] Whether or not the HAProxy executable can be found.
+    # @see Rhapr::Environment#exec
+    def has_exec?
+      !exec.nil?
+    end
+
+    # @return [String, nil] The path to the HAProxy executable will be returned, if found. Set ENV variable $HAPROXY_BIN to override
+    def exec
+      return(@exec) if @exec
+
+      @exec   = ENV['HAPROXY_BIN']
+      @exec ||= `which haproxy`
+
+      if @exec.empty?
+        begin
+          `haproxy -v`
+          @exec = 'haproxy'
+        rescue Errno::ENOENT => e
+          @exec = nil
+        end
+      end
+
+      return(@exec)
+    end
+
+    # @return [UNIXSocket] A connection to the HAProxy Socket
+    # @raise [RuntimeError] Raised if a socket connection could not be established
+    def socket
+      begin
+        UNIXSocket.open(socket_path)
+      rescue Errno::EACCES => e
+        raise RuntimeError.new("Could not open a socket with HAProxy. Error message: #{e.message}")
+      end
+    end
+
+    # @return [String] The path to the HAProxy stats socket.
+    # @raise [RuntimeError] Raised if no stats socket has been specified, in the HAProxy configuration.
+    # @todo: Should there be an ENV var for this? Perhaps allow config-less runs of rhapr?
+    def socket_path
+      @socket_path  ||= begin
+                          config.match /stats\s+socket\s+([^\s]*)/
+                          $1 || raise(RuntimeError.new "Expecting 'stats socket <UNIX_socket_path>' in #{config_path}")
+                        end
+    end
+
+    # @return [String] Returns the path to the pidfile, specified in the HAProxy configuration. Returns an assumption, if not found.
+    # @todo: Should there even be an assumption? Does HAProxy create a pid file, if not told to by the configuration?
+    # @todo: Should there be an ENV var for this? Perhaps allow config-less runs of rhapr?
+    def pid
+      @pid  ||= begin
+                  config.match /pidfile ([^\s]*)/
+                  $1 || '/var/run/haproxy.pid'
+                end
+    end
+
+    # @return [String, nil] Returns the PID of HAProxy as a string, if running. Nil otherwise.
+    # @todo: Look for something other than pidof, for searching the process list.
+    #   Could read from the pid file, but there's potential that it will go stale.
+    def check_running
+      pidof = `pidof haproxy`
+      pidof.strip!
+
+      return pidof unless pidof.empty?
+    end
+    alias :pidof :check_running
+  end
+end

data/rhapr/lib/rhapr/interface.rb

@@ -0,0 +1,111 @@
+require 'csv'
+
+module Rhapr
+  class Interface
+    include Rhapr::Environment
+
+    EMPTY = "\n"
+
+    # @param [String, #to_s] message The message to be sent to HAProxy
+    # return [Array<String>] All of the output from HAProxy, read in.
+    # @see Rhapr::Interface#write, Rhapr::Interface#read_full
+    def send(message)
+      sock = socket
+
+      write(sock, message)
+      read_full(sock)
+    end
+
+    # @return [true, false] Whether or not the 'clear counters' command was successful
+    def clear_counters
+      resp = send 'clear counters'
+      resp == EMPTY
+    end
+    alias :clear :clear_counters
+
+    # @return [Hash{String => String}] The 'show info' attributes, from HAProxy, parsed into a Hash.
+    def show_info
+      resp = send 'show info'
+
+      attrs = resp.split("\n")
+
+      attrs.map! {|line|
+        _attr, *_val = line.split(/: /)
+        [ _attr, _val.join ]
+      }
+
+      Hash[ attrs ]
+    end
+    alias :info :show_info
+
+    # @return [Array<Hash{String => String}>] The 'show stat' response, from HAProxy, parsed into an Array of Hashes.
+    def show_stat
+      resp = send 'show stat'
+      resp.gsub!(/^# /, '')
+
+      csv = CSV.parse(resp, :headers => true)
+      out = csv.map(&:to_a)
+
+      out.map!{|row| Hash[ row ]}
+
+      return(out)
+    end
+    alias :stat :show_stat
+
+    # @todo: Implement. I do not know the possible errors that may be present, nor how HAProxy will render them.
+    def show_errors
+    end
+    alias :errors :show_errors
+
+    # @todo: Implement. Not sure how this should look. It's likely that I will want to 'interpret' the data that is spit out.
+    def show_sess(id)
+    end
+    alias :session :show_sess
+
+    # @return [Array<Fixnum, Fixnum>] An Array with Two Elements: the Current Weight and the Initial Weight.
+    # @todo: Allow the numeric id to be used as a parameter?
+    def get_weight(backend, server)
+      resp = send "get weight #{backend}/#{server}"
+
+      resp.match /([[:digit:]]+) \(initial ([[:digit:]]+)\)/
+      weight, initial = $1, $2
+
+      return [weight.to_i, initial.to_i] if weight and initial
+
+      raise ArgumentError.new("HAProxy did not recognize the specified Backend/Server. Response from HAProxy: #{resp}")
+    end
+
+    # @todo: Implement.
+    # @todo: Allow the numeric id to be used as a parameter?
+    def set_weight(backend, server, weight)
+    end
+
+    # @todo: Implement.
+    def disable(backend, server)
+    end
+
+    # @todo: Implement.
+    def enable(backend, server)
+    end
+
+   protected
+    # @param [UNIXSocket]
+    # @param [String]
+    # @return [nil]
+    def write(socket, message)
+      socket.puts message
+    end
+
+    # @return [String]
+    def read(socket)
+      socket.gets
+    end
+
+    # @return [Array<String>] All of the output from HAProxy, read in.
+    # @see Rhapr::Interface#read
+    def read_full(socket)
+      output = []
+      output << read(socket) until(sock.eof?)
+    end
+  end
+end

data/rhapr/lib/rhapr/version.rb

@@ -0,0 +1,3 @@
+module Rhapr
+  VERSION = '0.0.1'
+end

data/rhapr/rhapr.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'rhapr/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'rhapr'
+  s.version     = Rhapr::VERSION
+  s.authors     = ['Scott Gonyea']
+  s.email       = ['me@sgonyea.com']
+  s.homepage    = 'https://github.com/sgonyea/rhapr'
+  s.summary     = %q{Rhapr wraps around HAProxy}
+  s.description = %q{Rhapr is a ruby lib that wraps around HAProxy, enabling you to sanely decomission a process.}
+
+  s.add_dependency 'yard', '~>0.6'
+
+  s.add_development_dependency 'rspec', '~>2.4'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/rhapr/spec/config_fixtures/basic_haproxy.cfg

@@ -0,0 +1,34 @@
+global
+    daemon
+    maxconn 1024
+    # quiet
+    pidfile /var/run/haproxy.pid
+    stats socket /tmp/haproxy level admin uid 501 group staff
+
+defaults
+    log global
+    mode http
+    option httplog
+    option dontlognull
+    stats enable
+    stats uri /proxystats     # and this guy for statistics
+    stats auth webreport:areallysecretsupersecurepassword
+    stats refresh 5s
+
+listen thrift :9090
+    mode    tcp
+    balance roundrobin
+    option  tcplog
+    option  redispatch
+    retries 3
+
+    contimeout  5000
+    clitimeout  40000
+    srvtimeout  7000
+
+    server thrift1 localhost:9091 maxconn 20 check inter 20000
+    server thrift2 localhost:9092 maxconn 20 check inter 20000
+    server thrift3 localhost:9093 maxconn 20 check inter 20000
+    server thrift4 localhost:9094 maxconn 20 check inter 20000
+    server thrift5 localhost:9095 maxconn 20 check inter 20000
+    server thrift6 localhost:9096 maxconn 20 check inter 20000

data/rhapr/spec/config_fixtures/crappy_haproxy.cfg

@@ -0,0 +1,4 @@
+global
+    daemon
+    maxconn 100
+    quiet

data/rhapr/spec/config_fixtures/pid_test_haproxy.cfg

@@ -0,0 +1,6 @@
+global
+    daemon
+    maxconn 1024
+    # quiet
+    pidfile /some/other/run/haproxy.pid
+    stats socket /tmp/haproxy level admin

data/rhapr/spec/quality_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+IGNORE = /\.(gitmodules|png$|tar$|gz$|rbc$|gem$|pdf$)/
+
+describe 'The application itself' do
+  it 'has no malformed whitespace' do
+    files = `git ls-files`.split("\n").select {|fn| fn !~ IGNORE}
+
+    files.should be_well_formed
+  end
+end

data/rhapr/spec/rhapr/environment_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe Rhapr::Environment do
+  class EnvTest
+    include Rhapr::Environment
+  end
+
+  before(:each) do
+    @env_test = EnvTest.new
+  end
+
+  describe '#config_path' do
+    it 'should set to the ENV variable, if present' do
+      ENV['HAPROXY_CONFIG'] = '/some/path.cfg'
+
+      @env_test.config_path.should == '/some/path.cfg'
+
+      # Clean up.
+      ENV.delete 'HAPROXY_CONFIG'
+    end
+
+    it 'should go down a list of pre-defined file names' do
+      File.stub!(:exists?).and_return(false)
+      File.should_receive(:exists?).with('/etc/haproxy.cfg').and_return(true)
+
+      @env_test.config_path.should == '/etc/haproxy.cfg'
+    end
+
+    it 'should select the first configuration found, from the pre-defined list' do
+      File.stub!(:exists?).and_return(false)
+      File.should_receive(:exists?).with('/etc/haproxy/haproxy.cfg').and_return(true)
+      File.should_receive(:exists?).with('/etc/haproxy.cfg').and_return(true)
+
+      @env_test.config_path.should == '/etc/haproxy/haproxy.cfg'
+    end
+
+    it 'should be nil if config files do not exist and $HAPROXY_CONFIG is not set' do
+      File.stub!(:exists?).and_return(false)
+      @env_test.config_path.should be_nil
+    end
+  end
+
+  describe '#config' do
+    before(:each) do
+      File.stub!(:exists?).and_return(false)
+      File.should_receive(:exists?).with('/etc/haproxy.cfg').and_return(true)
+    end
+
+    it 'should raise an exception if it cannot read from #config_path' do
+      File.should_receive(:read).and_raise(Errno::ENOENT)
+
+      lambda {
+        @env_test.config
+      }.should raise_error(RuntimeError)
+    end
+
+    it 'should read and return the contents of a file' do
+      File.should_receive(:read).and_return { "I can haz cfg ?\n" }
+
+      @env_test.config.should == "I can haz cfg ?\n"
+    end
+  end
+
+  describe '#exec' do
+    it 'should set to the ENV variable, if present' do
+      ENV['HAPROXY_BIN'] = '/usr/local/bin/haproxy'
+
+      @env_test.exec.should == '/usr/local/bin/haproxy'
+
+      # Clean up.
+      ENV.delete 'HAPROXY_BIN'
+    end
+
+    it 'should call out to the `which` command to find haproxy, if the ENV var is not set' do
+      @env_test.should_receive(:`).with('which haproxy').and_return('/opt/bin/haproxy')
+
+      @env_test.exec.should == '/opt/bin/haproxy'
+    end
+
+    it 'should call out to haproxy directly, if all else fails' do
+      @env_test.should_receive(:`).with('which haproxy').and_return('')
+      @env_test.should_receive(:`).with('haproxy -v').and_return("HA-Proxy version 1.4.15 2011/04/08\nCopyright 2000-2010 Willy Tarreau <w@1wt.eu>\n\n")
+
+      @env_test.exec.should == 'haproxy'
+    end
+
+    it 'should be nil if none of the above worked' do
+      @env_test.should_receive(:`).with('which haproxy').and_return('')
+      @env_test.should_receive(:`).with('haproxy -v').and_raise(Errno::ENOENT)
+
+      @env_test.exec.should be_nil
+    end
+  end
+
+  describe '#socket' do
+    it 'should establish a socket connection with HAProxy'
+  end
+
+  describe '#socket_path' do
+    it 'should parse out the io socket from the config file' do
+      @env_test.should_receive(:config).and_return { config_for(:basic_haproxy) }
+
+      @env_test.socket_path.should == '/tmp/haproxy'
+    end
+
+    it 'should raise an error if it cannot derive an io socket from the config file' do
+      @env_test.should_receive(:config).and_return { config_for(:crappy_haproxy) }
+
+      lambda {
+        @env_test.socket_path
+      }.should raise_error(RuntimeError)
+    end
+  end
+
+  describe '#pid' do
+    it 'should parse out the pidfile from the config file' do
+      @env_test.should_receive(:config).and_return { config_for(:pid_test_haproxy) }
+
+      @env_test.pid.should == '/some/other/run/haproxy.pid'
+    end
+
+    it 'should return a default path if it cannot derive an io socket from the config file' do
+      @env_test.should_receive(:config).and_return { config_for(:crappy_haproxy) }
+
+      @env_test.pid.should == '/var/run/haproxy.pid'
+    end
+  end
+
+  describe '#check_running, #pidof' do
+    pending 'TBD'
+  end
+end