shellac-repl 0.1.1

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rake'
+require 'fileutils'
+$LOAD_PATH << File.expand_path("lib/", __FILE__)
+require File.dirname(__FILE__) + '/lib/shellac/version'
+
+desc 'Run tests'
+task :test do
+  sh 'rspec spec/'
+end
+
+
+desc 'Build gem'
+task :build do
+  sh 'gem build shellac.gemspec'
+  gem_file = "shellac-repl-#{Shellac::VERSION}.gem"
+  FileUtils.mkdir_p 'gems'
+  FileUtils.mv gem_file, 'gems', :force => true
+end
+
+task :default => :test

data/bin/shellac

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require "shellac"
+
+shellac = Shellac::Runner.new
+
+shellac.run
+

data/lib/headers.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+#
+# Headers - A simple class defining basic attributes and methods for HTTP headers.
+#
+
+class Headers
+  # Not much here. Instantiate a hash to store HTTP headers.
+  def initialize
+    @headers = {}
+  end
+
+  # Add a header to the @headers hash.
+  def add_header(key, value)
+    if @headers.has_key?(key)
+      # If the value is a string, turn it into an array...
+      if @headers[key].is_a?(String)
+        previous_value = @headers[key]
+        @headers[key] = [previous_value, value]
+      # ... else append to the array.
+      else
+        @headers[key] << value
+      end
+    else
+      @headers[key] = value
+    end
+  end
+
+  # Return the @headers hash.
+  def headers
+    @headers
+  end
+
+  # If we reach this method, assume we want to find and return a value from
+  # the @headers hash using :method as the key name to look up.
+  # It's a hack, but this is an MVP.
+  def method_missing(method)
+    header_name = method.id2name
+    header_words = header_name.split('_')
+    header_words.each do |word|
+      word.capitalize!
+    end
+    header_name = header_words.join('-')
+    if @headers.has_key?(header_name)
+      # TODO: Add some color to help visually separate output. It'd be slick
+      # if we used a different color based on request/response object.
+      #puts "\e[1;33m#{@headers[header_name]}\e[0;0m"
+      @headers[header_name]
+    end
+  end
+
+end

data/lib/shellac.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require 'varnishclient/varnishclient'
+require 'varnishlog/varnishlog'
+require 'headers'
+require 'ripl'
+
+# Define some colors we'll use in some output.
+RED = "\e[1;31m"
+GREEN = "\e[1;32m"
+YELLOW = "\e[1;33m"
+NORMAL = "\e[0;0m"
+
+module Shellac
+
+  class Runner
+    attr_accessor :varnishclient, :varnishlog
+  
+    def initialize
+      @varnishclient = VarnishClient.new
+      @varnishlog = VarnishLog.new
+    end
+  
+    def run
+      # Inform the user of the default request.
+      puts "\nDefault request: #{RED}#{@varnishclient.request.uri.to_s}#{NORMAL}"
+      puts "HTTP Port (varnishclient.request.port): #{RED}#{@varnishclient.request.port}#{NORMAL}"
+      puts "HTTP Request Path (varnishclient.request.path): #{RED}#{@varnishclient.request.path}#{NORMAL}"
+      puts "HTTP Host Header (varnishclient.request.host): #{RED}#{@varnishclient.request.host}#{NORMAL}"
+      puts "\n#{RED}You may want to to modify this before calling #{NORMAL}@varnishclient.make_request#{RED}!#{NORMAL}"
+  
+      # Start our REPL.
+      Ripl.config[:prompt] = "\nshellac> "
+      # Bind Ripl to the context of this instance so that all of the objects
+      # accessible to it (and their methods) are accessible to the user in the REPL.
+      # 'binding' is a private method that returns a Binding object; we can only
+      # access it here via the #instance_eval method.
+      Ripl.start :binding => self.instance_eval{binding}
+    end
+  
+    # 1. Starts a thread to spawn a `varnishlog` subprocess that will catch our HTTP request.
+    # 2. Executes the HTTP request to Varnish.
+    # 3. Reaps the `varnishlog` thread so that its output can be parsed into the @varnishlog.response object.
+    # Returns nothing.
+    def make_request
+      @varnishlog.start_varnishlog_thread(@varnishclient.request.user_agent)
+      # Sleeping is a hack to give the varnishlog thread time to get in place.
+      # Without it, there's a roughly 50/50 chance (sometimes worse) that the thread
+      # will block on I/O as if it missed the HTTP request (because it did).
+      sleep(0.5)
+  
+      @varnishclient.response = @varnishclient.request.make_request
+
+      case @varnishclient.response.code
+      when /2\d{2}/
+        color = GREEN
+      when /3\d{2}/
+        color = YELLOW
+      when /4\d{2}/
+        color = RED
+      else
+        color = NORMAL
+      end
+      puts "\n#{@varnishclient.request.uri.to_s}: #{color}#{@varnishclient.response.code} #{@varnishclient.response.message}#{NORMAL}\n\n"
+
+      @varnishlog.reap_thread
+    end
+  end
+
+end

data/lib/shellac/version.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+module Shellac
+  VERSION = "0.1.1"
+end

data/lib/varnishclient/request.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require "net/http"
+require "uri"
+
+#
+# VarnishClient::Request - A class that wraps Net::HTTP::Request objects.
+#
+
+class VarnishClient
+  class Request
+
+    attr_accessor :uri, :request
+    # Initialize a VarnishClient::Request object.
+    def initialize
+      # Set some default values.
+      # We're running `varnishlog` on localhost.
+      default_http_hostname = 'http://localhost'
+      default_http_port = '80'
+      default_request_uri = '/'
+  
+      @uri = URI.parse("#{default_http_hostname}:#{default_http_port}#{default_request_uri}")
+      @http = Net::HTTP.new(@uri.host, @uri.port)
+      @request_headers = {
+        'Host' => 'www.example.com',
+        'User-Agent' => 'shellac'
+      }
+      @request = Net::HTTP::Get.new(@uri.request_uri, @request_headers)
+    end
+  
+    # Get the request headers.
+    def headers
+      @request_headers
+    end
+  
+    # Get the Host header for the request.
+    def host
+      @request['Host']
+    end
+  
+    # Set the Host header for the request.
+    def host=(host_header)
+      @request_headers['Host'] = host_header
+      @request = Net::HTTP::Get.new(@uri.request_uri, @request_headers)
+    end
+  
+    # Get the path of the request.
+    def path
+      @uri.request_uri
+    end
+  
+    # Set the path of the request.
+    def path=(path)
+      @uri.path = path
+      @request = Net::HTTP::Get.new(@uri.request_uri, @request_headers)
+    end
+  
+    # Get the port of the request.
+    def port
+      @uri.port
+    end
+  
+    # Set the port of the request.
+    def port=(port)
+      @uri.port = port
+      @http = Net::HTTP.new(@uri.host, @uri.port)
+      @request = Net::HTTP::Get.new(@uri.request_uri, @request_headers)
+    end
+  
+    # Get the User-Agent header.
+    def user_agent
+      @request['User-Agent']
+    end
+  
+    # Set the User-Agent header.
+    def user_agent=(user_agent)
+      @request_headers['User-Agent'] = user_agent
+      @request = Net::HTTP::Get.new(@uri.request_uri, @request_headers)
+    end
+  
+    # Make the HTTP request.
+    def make_request
+      response = @http.request(@request)
+    end
+
+  end
+end

data/lib/varnishclient/response.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require "net/http"
+
+#
+# VarnishClient::Response - A class that wraps Net::HTTP::Response objects.
+#
+
+# To be honest, we aren't doing anything here. This class exists in case
+# some sort of extra work needs to be done beyond what a Net::HTTPResponse
+# object provides.
+# (We're assigning the result of a Net::HTTPRequest to this object.)
+
+class VarnishClient
+  class Response
+
+    # Initialize a VarnishClient::Response object.
+    def initialize
+      @response = Net::HTTPResponse
+    end
+  
+  end
+end

data/lib/varnishclient/varnishclient.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'varnishclient/request'
+require 'varnishclient/response'
+
+#
+# VarnishClient - A class that wraps Net::HTTP objects as Varnish clients.
+#
+
+class VarnishClient
+
+  attr_accessor :request, :response
+  def initialize
+    @request = VarnishClient::Request.new
+    @response = VarnishClient::Response.new
+  end
+
+end

data/lib/varnishlog/request.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'headers'
+
+#
+# VarnishLog::Request - This class is used to create objects that represent HTTP
+#                       requests from Varnish's perspective.
+#
+
+class VarnishLog
+  class Request < Headers
+    @methods = [:method, :url, :protocol]
+    @methods.each do |method|
+      attr_accessor method
+    end
+
+    # Assume the powers of Headers.
+    def initialize
+      super
+    end
+
+  end
+end

data/lib/varnishlog/response.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'headers'
+
+#
+# VarnishLog::Response - This class is used to create objects that represent HTTP
+#                        responses from Varnish's perspective.
+#
+
+class VarnishLog
+  class Response < Headers
+
+    # Assume the powers of Headers.
+    def initialize
+      super
+    end
+
+  end
+end

data/lib/varnishlog/varnishlog.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+require 'varnishlog/request'
+require 'varnishlog/response'
+
+#
+# VarnishLog - A class to define objects that contain a transaction captured
+#              by `varnishlog`.
+#
+
+class VarnishLog
+  attr_reader :request, :response
+
+  # Create a new VarnishLog object.
+  #
+  # Returns a VarnishLog object with two attributes that are request and response objects.
+  def initialize
+    @request = VarnishLog::Request.new
+    @response = VarnishLog::Response.new
+  end
+
+  def start_varnishlog_thread(user_agent="shellac")
+    @varnishlog_thread = Thread.new {
+      output = `varnishlog -q 'ReqHeader:User-Agent eq "#{user_agent}"' -k 1`
+    }
+    @varnishlog_thread
+  end
+
+  def reap_thread
+    transaction = @varnishlog_thread.value
+    parse(transaction)
+  end
+
+  # Parses the output of a transaction captured by `varnishlog` into attributes
+  # that are assigned to a VarnishLog object.
+  def parse(transaction)
+    items = transaction.split("\n")
+
+    # Requests
+    ## Request headers.
+    request_headers = items.grep(/ReqHeader/)
+    request_headers.each do |header|
+      if match = /-\s+ReqHeader\s+(?<header_name>.*): (?<header_value>.*)/.match(header)
+        @request.add_header(match['header_name'], match['header_value'])
+      end
+    end
+
+    ## Match ReqMethod.
+    if method_match = /-\s+ReqMethod\s+(?<method>.*)/.match(items.grep(/ReqMethod/)[0])
+      @request.method = method_match['method']
+    end
+    ## Match ReqURL.
+    if url_match = /-\s+ReqURL\s+(?<url>\/.*)/.match(items.grep(/ReqURL/)[0])
+      @request.url = url_match['url']
+    end
+    ## Match ReqProtocol.
+    if protocol_match = /-\s+ReqProtocol\s+(?<protocol>.*)/.match(items.grep(/ReqProtocol/)[0])
+      @request.protocol = protocol_match['protocol']
+    end
+
+    # Response.
+    ## Response headers.
+    response_headers = items.grep(/RespHeader/)
+    response_headers.each do |header|
+      if match = /-\s+RespHeader\s+(?<header_name>.*): (?<header_value>.*)/.match(header)
+        @response.add_header(match['header_name'], match['header_value'])
+      end
+    end
+
+  end
+
+end

data/spec/shellac_spec.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+describe Shellac::Runner do
+
+  before :each do
+    @shellac = Shellac::Runner.new
+  end
+
+  describe "#new" do
+    it "Creates a new Shellac::Runner object" do
+      expect(described_class).to equal(Shellac::Runner)
+    end
+    it "Should have a .varnishlog attribute that's a VarnishLog object" do
+      expect(@shellac.varnishlog).to be_an_instance_of(VarnishLog)
+    end
+    it "Should have a .varnishclient attribute that's a VarnishClient object" do
+      expect(@shellac.varnishclient).to be_an_instance_of(VarnishClient)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/shellac'

data/spec/varnishclient_spec.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+describe VarnishClient do
+
+  before :each do
+    @varnishclient = VarnishClient.new
+  end
+
+  describe "#new" do
+    it "Creates a new VarnishClient object" do
+      expect(described_class).to equal(VarnishClient)
+    end
+    it "Should have a .request attribute that's a VarnishClient::Request object" do
+      expect(@varnishclient.request).to be_an_instance_of(VarnishClient::Request)
+    end
+    it "Should have a .response attribute that's a VarnishClient::Response object" do
+      expect(@varnishclient.response).to be_an_instance_of(VarnishClient::Response)
+    end
+  end
+
+  # Request-related tests.
+  describe "@varnishclient.request.host" do
+    it "defaults to 'www.example.com'" do
+      expect(@varnishclient.request.host).to eql('www.example.com')
+    end
+    it "can be updated to a custom host, like 'www.shellac.love'" do
+      @varnishclient.request.host = 'www.shellac.love'
+      expect(@varnishclient.request.host).to eql('www.shellac.love')
+    end
+  end
+
+  describe "@varnishclient.request.path" do
+    it "defaults to '/'" do
+      expect(@varnishclient.request.path).to eql('/')
+    end
+    it "can be updated to a custom path, like '/what-else-can-shellac-do.htm'" do
+      @varnishclient.request.path = '/what-else-can-shellac-do.htm'
+      expect(@varnishclient.request.path).to eql('/what-else-can-shellac-do.htm')
+    end
+  end
+
+  describe "@varnishclient.request.port" do
+    it "defaults to port 80" do
+      expect(@varnishclient.request.port).to eql(80)
+    end
+    it "can be updated to a custom port, like 1234" do
+      @varnishclient.request.port = 1234
+      expect(@varnishclient.request.port).to eql(1234)
+    end
+  end
+
+end

data/spec/varnishlog_spec.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+describe VarnishLog do
+
+  before :each do
+    @varnishlog = VarnishLog.new
+    varnishlog_output =  "*   << Request  >> 606123948 \n-   Begin          req 606123947 rxreq\n-   Timestamp      Start: 1454350985.766917 0.000000 0.000000\n-   Timestamp      Req: 1454350985.766917 0.000000 0.000000\n-   ReqStart       127.0.0.1 35937\n-   ReqMethod      GET\n-   ReqURL         /api/v7/find_user\n-   ReqProtocol    HTTP/1.1\n-   ReqHeader      Accept: */*\n-   ReqHeader      User-Agent: shellac\n-   ReqHeader      Host: www.example.com\n-   ReqHeader      Connection: close\n-   ReqHeader      X-Forwarded-For: 127.0.0.1\n-   VCL_call       RECV\n-   ReqUnset       X-Forwarded-For: 127.0.0.1\n-   ReqHeader      X-Forwarded-For: 127.0.0.1, 127.0.0.1\n-   VCL_return     hash\n-   VCL_call       HASH\n-   VCL_return     lookup\n-   Debug          \"XXXX MISS\"\n-   VCL_call       MISS\n-   VCL_return     fetch\n-   Link           bereq 606123949 fetch\n-   Timestamp      Fetch: 1454350985.832164 0.065247 0.065247\n-   RespProtocol   HTTP/1.1\n-   RespStatus     200\n-   RespReason     OK\n-   RespHeader     Date: Mon, 01 Feb 2016 18:23:05 GMT\n-   RespHeader     Server: Apache\n-   RespHeader     Cache-Control: max-age=60, public\n-   RespHeader     Vary: Accept-Encoding\n-   RespHeader     Content-Encoding: gzip\n-   RespHeader     Content-Length: 726\n-   RespHeader     X-Cnection: close\n-   RespHeader     Content-Type: application/json\n-   RespHeader     X-Varnish: 606123948\n-   RespHeader     Age: 0\n-   RespHeader     Via: 1.1 varnish-v4\n-   VCL_call       DELIVER\n-   RespHeader     X-Cache-Status: MISS\n-   VCL_return     deliver\n-   Timestamp      Process: 1454350985.832222 0.065305 0.000057\n-   RespUnset      Content-Encoding: gzip\n-   RespUnset      Content-Length: 726\n-   RespHeader     Transfer-Encoding: chunked\n-   Debug          \"RES_MODE 48\"\n-   RespHeader     Connection: close\n-   RespHeader     Accept-Ranges: bytes\n-   Gzip           U D - 726 5243 80 80 5739\n-   Timestamp      Resp: 1454350985.832356 0.065439 0.000134\n-   Debug          \"XXX REF 2\"\n-   ReqAcct        148 0 148 522 5258 5780\n-   End            \n\n"
+    @varnishlog.parse(varnishlog_output)
+  end
+
+  describe "#new" do
+    it "creates a new VarnishLog object" do
+      expect(described_class).to equal(VarnishLog)
+    end
+    it "should have a .request attribute that's a VarnishLog::Request object" do
+      expect(@varnishlog.request).to be_an_instance_of(VarnishLog::Request)
+    end
+    it "should have a .response attribute that's a VarnishLog::Response object" do
+      expect(@varnishlog.response).to be_an_instance_of(VarnishLog::Response)
+    end
+  end
+
+  # Test an explicitly defined method.
+  describe "@varnishlog.request.url" do
+    it "returns the URL path requested from Varnish" do
+      expect(@varnishlog.request.url).to eql("/api/v7/find_user")
+    end
+  end
+
+  # Test an implicitly defined method.
+  describe "@varnishlog.response.date" do
+    it "returns the Date response header sent by Varnish" do
+      expect(@varnishlog.response.date).to eql("Mon, 01 Feb 2016 18:23:05 GMT")
+    end
+  end
+
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: shellac-repl
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Frantz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ripl
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+description: ! "  shellac is a REPL for Varnish's varnishlog command.\n  It's a simple
+  tool for interacting with an HTTP request/response \n  and the request/response
+  seen/sent by varnishlog.\n  The goal is to help operators dissect activity on very
+  busy Varnish servers.\n"
+email:
+- ryanleefrantz@gmail.com
+executables:
+- shellac
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/headers.rb
+- lib/shellac.rb
+- lib/varnishclient/request.rb
+- lib/varnishclient/varnishclient.rb
+- lib/varnishclient/response.rb
+- lib/varnishlog/request.rb
+- lib/varnishlog/varnishlog.rb
+- lib/varnishlog/response.rb
+- lib/shellac/version.rb
+- bin/shellac
+- spec/varnishlog_spec.rb
+- spec/shellac_spec.rb
+- spec/varnishclient_spec.rb
+- spec/spec_helper.rb
+- Rakefile
+homepage: https://github.com/RyanFrantz/shellac
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23.2
+signing_key: 
+specification_version: 3
+summary: A REPL for Varnish's varnishlog command
+test_files: []